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

kivy/core/text/text_pango.py

@@ -0,0 +1,145 @@
+'''
+Pango text provider
+===================
+
+.. versionadded:: 1.11.0
+
+.. warning::
+    The low-level Pango API is experimental, and subject to change without
+    notice for as long as this warning is present.
+
+
+Installation
+------------
+
+1. Install pangoft2 (`apt install libfreetype6-dev libpango1.0-dev
+   libpangoft2-1.0-0`) or ensure it is available in pkg-config
+2. Recompile kivy. Check that pangoft2 is found `use_pangoft2 = 1`
+3. Test it! Enforce the text core renderer to pango using environment variable:
+   `export KIVY_TEXT=pango`
+
+This has been tested on OSX and Linux, Python 3.6.
+
+
+Font context types for FontConfig+FreeType2 backend
+---------------------------------------------------
+
+* `system://` - `FcInitLoadConfigAndFonts()`
+* `systemconfig://` - `FcInitLoadConfig()`
+* `directory://<PATH>` - `FcInitLoadConfig()` + `FcAppFontAddDir()`
+* `fontconfig://<PATH>` - `FcConfigCreate()` + `FcConfigParseAndLoad()`
+* Any other context name - `FcConfigCreate()`
+
+
+Low-level Pango access
+----------------------
+
+Since Kivy currently does its own text layout, the Label and TextInput widgets
+do not take full advantage of Pango. For example, line breaks do not take
+language/script into account, and switching alignment per paragraph (for bi-
+directional text) is not supported. For advanced i18n requirements, we provide
+a simple wrapper around PangoLayout that you can use to render text.
+
+* https://developer.gnome.org/pango/1.40/pango-Layout-Objects.html
+* https://developer.gnome.org/pango/1.40/PangoMarkupFormat.html
+* See the `kivy/core/text/_text_pango.pyx` file @ `cdef class KivyPangoLayout`
+  for more information. Not all features of PangoLayout are implemented.
+
+.. python::
+    from kivy.core.window import Window  # OpenGL must be initialized
+    from kivy.core.text._text_pango import KivyPangoLayout
+    layout = KivyPangoLayout('system://')
+    layout.set_markup('<span font="20">Hello <b>World!</b></span>')
+    tex = layout.render_as_Texture()
+
+
+Known limitations
+-----------------
+
+* Pango versions older than v1.38 has not been tested. It may work on
+  some systems with older pango and newer FontConfig/FreeType2 versions.
+* Kivy's text layout is used, not Pango. This means we do not use Pango's
+  line-breaking feature (which is superior to Kivy's), and we can't use
+  Pango's bidirectional cursor helpers in TextInput.
+* Font family collisions can happen. For example, if you use a `system://`
+  context and add a custom `Arial.ttf`, using `arial` as the `font_family`
+  may or may not draw with your custom font (depending on whether or not
+  there is already a system-wide "arial" font installed)
+* Rendering is inefficient; the normal way to integrate Pango would be
+  using a dedicated PangoLayout per widget. This is not currently practical
+  due to missing abstractions in Kivy core (in the current implementation,
+  we have a dedicated PangoLayout *per font context,* which is rendered
+  once for each LayoutWord)
+'''
+
+__all__ = ('LabelPango', )
+
+from types import MethodType
+from os.path import isfile
+from kivy.resources import resource_find
+from kivy.core.text import LabelBase, FontContextManagerBase
+from kivy.core.text._text_pango import (
+        KivyPangoRenderer,
+        kpango_get_extents,
+        kpango_get_ascent,
+        kpango_get_descent,
+        kpango_find_base_dir,
+        kpango_font_context_exists,
+        kpango_font_context_create,
+        kpango_font_context_destroy,
+        kpango_font_context_add_font,
+        kpango_font_context_list,
+        kpango_font_context_list_custom,
+        kpango_font_context_list_families)
+
+
+class LabelPango(LabelBase):
+
+    _font_family_support = True
+
+    def __init__(self, *largs, **kwargs):
+        self.get_extents = MethodType(kpango_get_extents, self)
+        self.get_ascent = MethodType(kpango_get_ascent, self)
+        self.get_descent = MethodType(kpango_get_descent, self)
+        super(LabelPango, self).__init__(*largs, **kwargs)
+
+    find_base_direction = staticmethod(kpango_find_base_dir)
+
+    def _render_begin(self):
+        self._rdr = KivyPangoRenderer(*self._size)
+
+    def _render_text(self, text, x, y):
+        self._rdr.render(self, text, x, y)
+
+    def _render_end(self):
+        imgdata = self._rdr.get_ImageData()
+        del self._rdr
+        return imgdata
+
+
+class PangoFontContextManager(FontContextManagerBase):
+    create = staticmethod(kpango_font_context_create)
+    exists = staticmethod(kpango_font_context_exists)
+    destroy = staticmethod(kpango_font_context_destroy)
+    list = staticmethod(kpango_font_context_list)
+    list_families = staticmethod(kpango_font_context_list_families)
+    list_custom = staticmethod(kpango_font_context_list_custom)
+
+    @staticmethod
+    def add_font(font_context, filename, autocreate=True, family=None):
+        if not autocreate and not PangoFontContextManager.exists(font_context):
+            raise Exception("FontContextManager: Attempt to add font file "
+                            "'{}' to non-existing context '{}' without "
+                            "autocreate.".format(filename, font_context))
+        if not filename:
+            raise Exception("FontContextManager: Cannot add empty font file")
+        if not isfile(filename):
+            filename = resource_find(filename)
+        if not isfile(filename):
+            if not filename.endswith('.ttf'):
+                filename = resource_find('{}.ttf'.format(filename))
+        if filename and isfile(filename):
+            return kpango_font_context_add_font(font_context, filename)
+        raise Exception("FontContextManager: Attempt to add non-existent "
+                        "font file: '{}' to context '{}'"
+                        .format(filename, font_context))

kivy/core/text/text_pil.py

@@ -0,0 +1,84 @@
+'''
+Text PIL: Draw text with PIL
+'''
+
+__all__ = ('LabelPIL', )
+
+from PIL import Image, ImageFont, ImageDraw
+
+
+from kivy.compat import text_type
+from kivy.core.text import LabelBase
+from kivy.core.image import ImageData
+
+# used for fetching extends before creature image surface
+default_font = ImageFont.load_default()
+
+
+class LabelPIL(LabelBase):
+    _cache = {}
+
+    def _select_font(self):
+        if self.options['font_size'] < 1:
+            return None
+
+        fontsize = int(self.options['font_size'])
+        fontname = self.options['font_name_r']
+        try:
+            id = '%s.%s' % (text_type(fontname), text_type(fontsize))
+        except UnicodeDecodeError:
+            id = '%s.%s' % (fontname, fontsize)
+
+        if id not in self._cache:
+            font = ImageFont.truetype(fontname, fontsize)
+            self._cache[id] = font
+
+        return self._cache[id]
+
+    def get_extents(self, text):
+        font = self._select_font()
+        if not font:
+            return 0, 0
+
+        left, top, right, bottom = font.getbbox(text)
+        ascent, descent = font.getmetrics()
+
+        if self.options['limit_render_to_text_bbox']:
+            h = bottom - top
+        else:
+            h = ascent + descent
+        w = right - left
+
+        return w, h
+
+    def get_cached_extents(self):
+        return self.get_extents
+
+    def _render_begin(self):
+        # create a surface, context, font...
+        self._pil_im = Image.new('RGBA', self._size, color=(255, 255, 255, 0))
+        self._pil_draw = ImageDraw.Draw(self._pil_im)
+
+    def _render_text(self, text, x, y):
+        font = self._select_font()
+        if not font:
+            return
+
+        color = tuple([int(c * 255) for c in self.options['color']])
+
+        # Adjust x and y position to avoid text cutoff
+        if self.options['limit_render_to_text_bbox']:
+            bbox = font.getbbox(text)
+            x -= bbox[0]
+            y -= bbox[1]
+
+        self._pil_draw.text((int(x), int(y)), text, font=font, fill=color)
+
+    def _render_end(self):
+        data = ImageData(self._size[0], self._size[1],
+                         self._pil_im.mode.lower(), self._pil_im.tobytes())
+
+        del self._pil_im
+        del self._pil_draw
+
+        return data

kivy/core/text/text_pygame.py

@@ -0,0 +1,117 @@
+'''
+Text Pygame: Draw text with pygame
+
+.. warning::
+
+    Pygame has been deprecated and will be removed in the release after Kivy
+    1.11.0.
+'''
+
+__all__ = ('LabelPygame', )
+
+from kivy.compat import PY2
+from kivy.core.text import LabelBase
+from kivy.core.image import ImageData
+from kivy.utils import deprecated
+
+try:
+    import pygame
+except:
+    raise
+
+pygame_cache = {}
+pygame_font_handles = {}
+pygame_cache_order = []
+
+# init pygame font
+try:
+    pygame.ftfont.init()
+except:
+    pygame.font.init()
+
+
+class LabelPygame(LabelBase):
+
+    @deprecated(
+        msg='Pygame has been deprecated and will be removed after 1.11.0')
+    def __init__(self, *largs, **kwargs):
+        super(LabelPygame, self).__init__(*largs, **kwargs)
+
+    def _get_font_id(self):
+        return '|'.join([str(self.options[x]) for x in
+                         ('font_size', 'font_name_r', 'bold', 'italic')])
+
+    def _get_font(self):
+        fontid = self._get_font_id()
+        if fontid not in pygame_cache:
+            # try first the file if it's a filename
+            font_handle = fontobject = None
+            fontname = self.options['font_name_r']
+            ext = fontname.rsplit('.', 1)
+            if len(ext) == 2:
+                # try to open the font if it has an extension
+                font_handle = open(fontname, 'rb')
+                fontobject = pygame.font.Font(font_handle,
+                                              int(self.options['font_size']))
+
+            # fallback to search a system font
+            if fontobject is None:
+                # try to search the font
+                font = pygame.font.match_font(
+                    self.options['font_name_r'].replace(' ', ''),
+                    bold=self.options['bold'],
+                    italic=self.options['italic'])
+
+                # fontobject
+                fontobject = pygame.font.Font(font,
+                                              int(self.options['font_size']))
+            pygame_cache[fontid] = fontobject
+            pygame_font_handles[fontid] = font_handle
+            pygame_cache_order.append(fontid)
+
+        # to prevent too much file open, limit the number of opened fonts to 64
+        while len(pygame_cache_order) > 64:
+            popid = pygame_cache_order.pop(0)
+            del pygame_cache[popid]
+            font_handle = pygame_font_handles.pop(popid)
+            if font_handle is not None:
+                font_handle.close()
+
+        return pygame_cache[fontid]
+
+    def get_ascent(self):
+        return self._get_font().get_ascent()
+
+    def get_descent(self):
+        return self._get_font().get_descent()
+
+    def get_extents(self, text):
+        return self._get_font().size(text)
+
+    def get_cached_extents(self):
+        return self._get_font().size
+
+    def _render_begin(self):
+        self._pygame_surface = pygame.Surface(self._size, pygame.SRCALPHA, 32)
+        self._pygame_surface.fill((0, 0, 0, 0))
+
+    def _render_text(self, text, x, y):
+        font = self._get_font()
+        color = [c * 255 for c in self.options['color']]
+        color[0], color[2] = color[2], color[0]
+        try:
+            text = font.render(text, True, color)
+            text.set_colorkey(color)
+            self._pygame_surface.blit(text, (x, y), None,
+                                      pygame.BLEND_RGBA_ADD)
+        except pygame.error:
+            pass
+
+    def _render_end(self):
+        w, h = self._size
+        data = ImageData(w, h,
+                         'rgba', self._pygame_surface.get_buffer().raw)
+
+        del self._pygame_surface
+
+        return data

kivy/core/text/text_sdl2.py

@@ -0,0 +1,50 @@
+'''
+SDL2 text provider
+==================
+
+Based on SDL2 + SDL2_ttf
+'''
+
+__all__ = ('LabelSDL2', )
+
+from kivy.compat import PY2
+from kivy.core.text import LabelBase
+try:
+    from kivy.core.text._text_sdl2 import (_SurfaceContainer, _get_extents,
+                                           _get_fontdescent, _get_fontascent)
+except ImportError:
+    from kivy.core import handle_win_lib_import_error
+    handle_win_lib_import_error(
+        'text', 'sdl2', 'kivy.core.text._text_sdl2')
+    raise
+
+
+class LabelSDL2(LabelBase):
+
+    def _get_font_id(self):
+        return '|'.join([str(self.options[x]) for x
+            in ('font_size', 'font_name_r', 'bold',
+                'italic', 'underline', 'strikethrough')])
+
+    def get_extents(self, text):
+        try:
+            if PY2:
+                text = text.encode('UTF-8')
+        except:
+            pass
+        return _get_extents(self, text)
+
+    def get_descent(self):
+        return _get_fontdescent(self)
+
+    def get_ascent(self):
+        return _get_fontascent(self)
+
+    def _render_begin(self):
+        self._surface = _SurfaceContainer(self._size[0], self._size[1])
+
+    def _render_text(self, text, x, y):
+        self._surface.render(self, text, x, y)
+
+    def _render_end(self):
+        return self._surface.get_data()

kivy/core/video/__init__.py

@@ -0,0 +1,219 @@
+'''
+Video
+=====
+
+Core class for reading video files and managing the video
+:class:`~kivy.graphics.texture.Texture`.
+
+.. versionchanged:: 1.10.0
+    The pyglet, pygst and gi providers have been removed.
+
+.. versionchanged:: 1.8.0
+    There are now 2 distinct Gstreamer implementations: one using Gi/Gst
+    working for both Python 2+3 with Gstreamer 1.0, and one using PyGST
+    working only for Python 2 + Gstreamer 0.10.
+
+.. note::
+
+    Recording is not supported.
+'''
+
+__all__ = ('VideoBase', 'Video')
+
+from kivy.clock import Clock
+from kivy.core import core_select_lib
+from kivy.event import EventDispatcher
+from kivy.logger import Logger
+from kivy.compat import PY2
+
+
+class VideoBase(EventDispatcher):
+    '''VideoBase, a class used to implement a video reader.
+
+    :Parameters:
+        `filename`: str
+            Filename of the video. Can be a file or an URI.
+        `eos`: str, defaults to 'pause'
+            Action to take when EOS is hit. Can be one of 'pause', 'stop' or
+            'loop'.
+
+            .. versionchanged:: 1.4.0
+                added 'pause'
+
+        `async`: bool, defaults to True
+            Load the video asynchronously (may be not supported by all
+            providers).
+        `autoplay`: bool, defaults to False
+            Auto play the video on init.
+
+    :Events:
+        `on_eos`
+            Fired when EOS is hit.
+        `on_load`
+            Fired when the video is loaded and the texture is available.
+        `on_frame`
+            Fired when a new frame is written to the texture.
+    '''
+
+    __slots__ = ('_wantplay', '_buffer', '_filename', '_texture',
+                 '_volume', 'eos', '_state', '_async', '_autoplay')
+
+    __events__ = ('on_eos', 'on_load', 'on_frame')
+
+    def __init__(self, **kwargs):
+        kwargs.setdefault('filename', None)
+        kwargs.setdefault('eos', 'stop')
+        kwargs.setdefault('async', True)
+        kwargs.setdefault('autoplay', False)
+
+        super(VideoBase, self).__init__()
+
+        self._wantplay = False
+        self._buffer = None
+        self._filename = None
+        self._texture = None
+        self._volume = 1.
+        self._state = ''
+
+        self._autoplay = kwargs.get('autoplay')
+        self._async = kwargs.get('async')
+        self.eos = kwargs.get('eos')
+        if self.eos == 'pause':
+            Logger.warning("'pause' is deprecated. Use 'stop' instead.")
+            self.eos = 'stop'
+        self.filename = kwargs.get('filename')
+
+        Clock.schedule_interval(self._update, 1 / 30.)
+
+        if self._autoplay:
+            self.play()
+
+    def __del__(self):
+        self.unload()
+
+    def on_eos(self):
+        pass
+
+    def on_load(self):
+        pass
+
+    def on_frame(self):
+        pass
+
+    def _get_filename(self):
+        return self._filename
+
+    def _set_filename(self, filename):
+        if filename == self._filename:
+            return
+        self.unload()
+        self._filename = filename
+        if self._filename is None:
+            return
+        self.load()
+
+    filename = property(lambda self: self._get_filename(),
+                        lambda self, x: self._set_filename(x),
+                        doc='Get/set the filename/uri of the current video')
+
+    def _get_position(self):
+        return 0
+
+    def _set_position(self, pos):
+        self.seek(pos)
+
+    position = property(lambda self: self._get_position(),
+                        lambda self, x: self._set_position(x),
+                        doc='Get/set the position in the video (in seconds)')
+
+    def _get_volume(self):
+        return self._volume
+
+    def _set_volume(self, volume):
+        self._volume = volume
+
+    volume = property(lambda self: self._get_volume(),
+                      lambda self, x: self._set_volume(x),
+                      doc='Get/set the volume in the video (1.0 = 100%)')
+
+    def _get_duration(self):
+        return 0
+
+    duration = property(lambda self: self._get_duration(),
+                        doc='Get the video duration (in seconds)')
+
+    def _get_texture(self):
+        return self._texture
+
+    texture = property(lambda self: self._get_texture(),
+                       doc='Get the video texture')
+
+    def _get_state(self):
+        return self._state
+
+    state = property(lambda self: self._get_state(),
+                     doc='Get the video playing status')
+
+    def _do_eos(self, *args):
+        '''
+        .. versionchanged:: 1.4.0
+            Now dispatches the `on_eos` event.
+        '''
+        if self.eos == 'pause':
+            self.pause()
+        elif self.eos == 'stop':
+            self.stop()
+        elif self.eos == 'loop':
+            self.position = 0
+            self.play()
+
+        self.dispatch('on_eos')
+
+    def _update(self, dt):
+        '''Update the video content to texture.
+        '''
+        pass
+
+    def seek(self, percent, precise=True):
+        '''Move to position as percentage (strictly, a proportion from
+            0 - 1) of the duration'''
+        pass
+
+    def stop(self):
+        '''Stop the video playing'''
+        self._state = ''
+
+    def pause(self):
+        '''Pause the video
+
+        .. versionadded:: 1.4.0
+        '''
+        self._state = 'paused'
+
+    def play(self):
+        '''Play the video'''
+        self._state = 'playing'
+
+    def load(self):
+        '''Load the video from the current filename'''
+        pass
+
+    def unload(self):
+        '''Unload the actual video'''
+        self._state = ''
+
+
+# Load the appropriate provider
+video_providers = []
+try:
+    from kivy.lib.gstplayer import GstPlayer  # NOQA
+    video_providers += [('gstplayer', 'video_gstplayer', 'VideoGstplayer')]
+except ImportError:
+    pass
+video_providers += [
+    ('ffmpeg', 'video_ffmpeg', 'VideoFFMpeg'),
+    ('ffpyplayer', 'video_ffpyplayer', 'VideoFFPy'),
+    ('null', 'video_null', 'VideoNull')]
+
+
+Video = core_select_lib('video', video_providers)