pgzero-plus 0.1.0__py3-none-any.whl

pgzero/ptext.py

@@ -0,0 +1,500 @@
+"""pygame-text - high-level text rendering with Pygame.
+
+This module is directly copied from
+
+    https://github.com/cosmologicon/pygame-text
+
+at revision c04e59b7382a832e117f0598cdcbc1bb3eb26db5
+and used under CC0.
+
+"""
+# ptext module: place this in your import directory.
+
+# ptext.draw(text, pos=None, **options)
+
+# Please see README.md for explanation of options.
+# https://github.com/cosmologicon/pygame-text
+
+# flake8: noqa: E501
+from __future__ import division
+
+from math import ceil, sin, cos, radians
+import pygame
+
+DEFAULT_FONT_SIZE = 24
+REFERENCE_FONT_SIZE = 100
+DEFAULT_LINE_HEIGHT = 1.0
+DEFAULT_FONT_NAME = None
+FONT_NAME_TEMPLATE = "%s"
+DEFAULT_COLOR = "white"
+DEFAULT_BACKGROUND = None
+DEFAULT_OUTLINE_COLOR = "black"
+DEFAULT_SHADOW_COLOR = "black"
+OUTLINE_UNIT = 1 / 24
+SHADOW_UNIT = 1 / 18
+DEFAULT_ALIGN = "left"  # left, center, or right
+DEFAULT_ANCHOR = 0, 0  # 0, 0 = top left ;  1, 1 = bottom right
+DEFAULT_STRIP = True
+ALPHA_RESOLUTION = 16
+ANGLE_RESOLUTION_DEGREES = 3
+
+AUTO_CLEAN = True
+MEMORY_LIMIT_MB = 64
+MEMORY_REDUCTION_FACTOR = 0.5
+
+pygame.font.init()
+
+_font_cache = {}
+
+
+def getfont(fontname=None, fontsize=None, sysfontname=None,
+            bold=None, italic=None, underline=None):
+    if fontname is not None and sysfontname is not None:
+        raise ValueError("Can't set both fontname and sysfontname")
+    if fontname is None and sysfontname is None:
+        fontname = DEFAULT_FONT_NAME
+    if fontsize is None:
+        fontsize = DEFAULT_FONT_SIZE
+    key = fontname, fontsize, sysfontname, bold, italic, underline
+    if key in _font_cache:
+        return _font_cache[key]
+    if sysfontname is not None:
+        font = pygame.font.SysFont(
+            sysfontname, fontsize, bold or False, italic or False)
+    else:
+        if fontname is not None:
+            fontname = FONT_NAME_TEMPLATE % fontname
+        try:
+            font = pygame.font.Font(fontname, fontsize)
+        except IOError:
+            raise IOError("unable to read font filename: %s" % fontname)
+    if bold is not None:
+        font.set_bold(bold)
+    if italic is not None:
+        font.set_italic(italic)
+    if underline is not None:
+        font.set_underline(underline)
+    _font_cache[key] = font
+    return font
+
+
+def wrap(text, fontname=None, fontsize=None, sysfontname=None,
+         bold=None, italic=None, underline=None, width=None, widthem=None, strip=None):
+    if widthem is None:
+        font = getfont(fontname, fontsize, sysfontname,
+                       bold, italic, underline)
+    elif width is not None:
+        raise ValueError("Can't set both width and widthem")
+    else:
+        font = getfont(fontname, REFERENCE_FONT_SIZE,
+                       sysfontname, bold, italic, underline)
+        width = widthem * REFERENCE_FONT_SIZE
+    if strip is None:
+        strip = DEFAULT_STRIP
+    texts = text.replace("\t", "    ").split("\n")
+    lines = []
+    for text in texts:
+        if strip:
+            text = text.rstrip(" ")
+        if width is None:
+            lines.append(text)
+            continue
+        if not text:
+            lines.append("")
+            continue
+        # Preserve leading spaces in all cases.
+        a = len(text) - len(text.lstrip(" "))
+        # At any time, a is the rightmost known index you can legally split a line. I.e. it's legal
+        # to add text[:a] to lines, and line is what will be added to lines if
+        # text is split at a.
+        a = text.index(" ", a) if " " in text else len(text)
+        line = text[:a]
+        while a + 1 < len(text):
+            # b is the next legal place to break the line, with bline the
+            # corresponding line to add.
+            if " " not in text[a + 1:]:
+                b = len(text)
+                bline = text
+            elif strip:
+                # Lines may be split at any space character that immediately follows a non-space
+                # character.
+                b = text.index(" ", a + 1)
+                while text[b - 1] == " ":
+                    if " " in text[b + 1:]:
+                        b = text.index(" ", b + 1)
+                    else:
+                        b = len(text)
+                        break
+                bline = text[:b]
+            else:
+                # Lines may be split at any space character, or any character immediately following
+                # a space character.
+                b = a + 1 if text[a] == " " else text.index(" ", a + 1)
+            bline = text[:b]
+            if font.size(bline)[0] <= width:
+                a, line = b, bline
+            else:
+                lines.append(line)
+                text = text[a:].lstrip(" ") if strip else text[a:]
+                a = text.index(" ", 1) if " " in text[1:] else len(text)
+                line = text[:a]
+        if text:
+            lines.append(line)
+    return lines
+
+
+_fit_cache = {}
+
+
+def _fitsize(text, fontname, sysfontname, bold, italic, underline, width, height, lineheight, strip):
+    key = text, fontname, sysfontname, bold, italic, underline, width, height, lineheight, strip
+    if key in _fit_cache:
+        return _fit_cache[key]
+
+    def fits(fontsize):
+        texts = wrap(text, fontname, fontsize, sysfontname,
+                     bold, italic, underline, width, strip)
+        font = getfont(fontname, fontsize, sysfontname,
+                       bold, italic, underline)
+        w = max(font.size(line)[0] for line in texts)
+        linesize = font.get_linesize() * lineheight
+        h = int(round((len(texts) - 1) * linesize)) + font.get_height()
+        return w <= width and h <= height
+    a, b = 1, 256
+    if not fits(a):
+        fontsize = a
+    elif fits(b):
+        fontsize = b
+    else:
+        while b - a > 1:
+            c = (a + b) // 2
+            if fits(c):
+                a = c
+            else:
+                b = c
+        fontsize = a
+    _fit_cache[key] = fontsize
+    return fontsize
+
+
+def _resolvecolor(color, default):
+    if color is None:
+        color = default
+    if color is None:
+        return None
+    try:
+        return tuple(pygame.Color(color))
+    except ValueError:
+        return tuple(color)
+
+
+def _resolvealpha(alpha):
+    if alpha >= 1:
+        return 1
+    return max(int(round(alpha * ALPHA_RESOLUTION)) / ALPHA_RESOLUTION, 0)
+
+
+def _resolveangle(angle):
+    if not angle:
+        return 0
+    angle %= 360
+    return int(round(angle / ANGLE_RESOLUTION_DEGREES)) * ANGLE_RESOLUTION_DEGREES
+
+
+# Return the set of points in the circle radius r, using Bresenham's
+# circle algorithm
+_circle_cache = {}
+
+
+def _circlepoints(r):
+    r = int(round(r))
+    if r in _circle_cache:
+        return _circle_cache[r]
+    x, y, e = r, 0, 1 - r
+    _circle_cache[r] = points = []
+    while x >= y:
+        points.append((x, y))
+        y += 1
+        if e < 0:
+            e += 2 * y - 1
+        else:
+            x -= 1
+            e += 2 * (y - x) - 1
+    points += [(y, x) for x, y in points if x > y]
+    points += [(-x, y) for x, y in points if x]
+    points += [(x, -y) for x, y in points if y]
+    points.sort()
+    return points
+
+
+_surf_cache = {}
+_surf_tick_usage = {}
+_surf_size_total = 0
+_unrotated_size = {}
+_tick = 0
+
+
+def getsurf(text, fontname=None, fontsize=None, sysfontname=None, bold=None, italic=None,
+            underline=None, width=None, widthem=None, strip=None, color=None,
+            background=None, antialias=True, ocolor=None, owidth=None, scolor=None, shadow=None,
+            gcolor=None, alpha=1.0, align=None, lineheight=None, angle=0, cache=True):
+    global _tick, _surf_size_total
+    if fontname is None:
+        fontname = DEFAULT_FONT_NAME
+    if fontsize is None:
+        fontsize = DEFAULT_FONT_SIZE
+    fontsize = int(round(fontsize))
+    if align is None:
+        align = DEFAULT_ALIGN
+    if align in ["left", "center", "right"]:
+        align = [0, 0.5, 1][["left", "center", "right"].index(align)]
+    if lineheight is None:
+        lineheight = DEFAULT_LINE_HEIGHT
+    color = _resolvecolor(color, DEFAULT_COLOR)
+    background = _resolvecolor(background, DEFAULT_BACKGROUND)
+    gcolor = _resolvecolor(gcolor, None)
+    ocolor = None if owidth is None else _resolvecolor(
+        ocolor, DEFAULT_OUTLINE_COLOR)
+    scolor = None if shadow is None else _resolvecolor(
+        scolor, DEFAULT_SHADOW_COLOR)
+    opx = None if owidth is None else ceil(owidth * fontsize * OUTLINE_UNIT)
+    spx = None if shadow is None else tuple(
+        ceil(s * fontsize * SHADOW_UNIT) for s in shadow)
+    alpha = _resolvealpha(alpha)
+    angle = _resolveangle(angle)
+    strip = DEFAULT_STRIP if strip is None else strip
+    key = (text, fontname, fontsize, sysfontname, bold, italic, underline, width, widthem, strip,
+           color, background, antialias, ocolor, opx, scolor, spx, gcolor, alpha, align, lineheight, angle)
+    if key in _surf_cache:
+        _surf_tick_usage[key] = _tick
+        _tick += 1
+        return _surf_cache[key]
+    texts = wrap(text, fontname, fontsize, sysfontname, bold, italic, underline,
+                 width=width, widthem=widthem, strip=strip)
+    if angle:
+        surf0 = getsurf(text, fontname, fontsize, sysfontname, bold, italic, underline,
+                        width, widthem, strip, color, background, antialias,
+                        ocolor, owidth, scolor, shadow, gcolor, alpha, align, lineheight, cache=cache)
+        if angle in (90, 180, 270):
+            surf = pygame.transform.rotate(surf0, angle)
+        else:
+            surf = pygame.transform.rotozoom(surf0, angle, 1.0)
+        _unrotated_size[(surf.get_size(), angle, text)] = surf0.get_size()
+    elif alpha < 1.0:
+        surf0 = getsurf(text, fontname, fontsize, sysfontname, bold, italic, underline,
+                        width, widthem, strip, color, background, antialias,
+                        ocolor, owidth, scolor, shadow, gcolor=gcolor, align=align,
+                        lineheight=lineheight, cache=cache)
+        surf = surf0.copy()
+        array = pygame.surfarray.pixels_alpha(surf)
+        array[:, :] = (array[:, :] * alpha).astype(array.dtype)
+        del array
+    elif spx is not None:
+        surf0 = getsurf(text, fontname, fontsize, sysfontname, bold, italic, underline,
+                        width, widthem, strip, color=color, background=(0, 0, 0, 0), antialias=antialias,
+                        gcolor=gcolor, align=align, lineheight=lineheight, cache=cache)
+        ssurf = getsurf(text, fontname, fontsize, sysfontname, bold, italic, underline,
+                        width, widthem, strip, color=scolor, background=(0, 0, 0, 0), antialias=antialias,
+                        align=align, lineheight=lineheight, cache=cache)
+        w0, h0 = surf0.get_size()
+        sx, sy = spx
+        surf = pygame.Surface((w0 + abs(sx), h0 + abs(sy))).convert_alpha()
+        surf.fill(background or (0, 0, 0, 0))
+        dx, dy = max(sx, 0), max(sy, 0)
+        surf.blit(ssurf, (dx, dy))
+        x0, y0 = abs(sx) - dx, abs(sy) - dy
+        if len(color) > 3 and color[3] == 0:
+            array = pygame.surfarray.pixels_alpha(surf)
+            array0 = pygame.surfarray.pixels_alpha(surf0)
+            array[x0:x0 + w0, y0:y0 +
+                  h0] -= array0.clip(max=array[x0:x0 + w0, y0:y0 + h0])
+            del array, array0
+        else:
+            surf.blit(surf0, (x0, y0))
+    elif opx is not None:
+        surf0 = getsurf(text, fontname, fontsize, sysfontname, bold, italic, underline,
+                        width, widthem, strip, color=color, background=(0, 0, 0, 0), antialias=antialias,
+                        gcolor=gcolor, align=align, lineheight=lineheight, cache=cache)
+        osurf = getsurf(text, fontname, fontsize, sysfontname, bold, italic, underline,
+                        width, widthem, strip, color=ocolor, background=(0, 0, 0, 0), antialias=antialias,
+                        align=align, lineheight=lineheight, cache=cache)
+        w0, h0 = surf0.get_size()
+        surf = pygame.Surface((w0 + 2 * opx, h0 + 2 * opx)).convert_alpha()
+        surf.fill(background or (0, 0, 0, 0))
+        for dx, dy in _circlepoints(opx):
+            surf.blit(osurf, (dx + opx, dy + opx))
+        if len(color) > 3 and color[3] == 0:
+            array = pygame.surfarray.pixels_alpha(surf)
+            array0 = pygame.surfarray.pixels_alpha(surf0)
+            array[opx:-opx, opx:-
+                  opx] -= array0.clip(max=array[opx:-opx, opx:-opx])
+            del array, array0
+        else:
+            surf.blit(surf0, (opx, opx))
+    else:
+        font = getfont(fontname, fontsize, sysfontname,
+                       bold, italic, underline)
+        # pygame.Font.render does not allow passing None as an argument value
+        # for background.
+        if background is None or (len(background) > 3 and background[3] == 0) or gcolor is not None:
+            lsurfs = [font.render(text, antialias, color).convert_alpha()
+                      for text in texts]
+        else:
+            lsurfs = [font.render(text, antialias, color,
+                                  background).convert_alpha() for text in texts]
+        if gcolor is not None:
+            import numpy
+            for lsurf in lsurfs:
+                m = numpy.clip(numpy.arange(
+                    lsurf.get_height()) * 2.0 / font.get_ascent() - 1.0, 0, 1)
+                array = pygame.surfarray.pixels3d(lsurf)
+                for j in (0, 1, 2):
+                    array[:, :, j] = (
+                        (1.0 - m) * array[:, :, j] + m * gcolor[j]).astype(array.dtype)
+                del array
+
+        if len(lsurfs) == 1 and gcolor is None:
+            surf = lsurfs[0]
+        else:
+            w = max(lsurf.get_width() for lsurf in lsurfs)
+            linesize = font.get_linesize() * lineheight
+            ys = [int(round(k * linesize)) for k in range(len(lsurfs))]
+            h = ys[-1] + font.get_height()
+            surf = pygame.Surface((w, h)).convert_alpha()
+            surf.fill(background or (0, 0, 0, 0))
+            for y, lsurf in zip(ys, lsurfs):
+                x = int(round(align * (w - lsurf.get_width())))
+                surf.blit(lsurf, (x, y))
+    if cache:
+        w, h = surf.get_size()
+        _surf_size_total += 4 * w * h
+        _surf_cache[key] = surf
+        _surf_tick_usage[key] = _tick
+        _tick += 1
+    return surf
+
+
+_default_surf_sentinel = ()
+
+
+def draw(text, pos=None,
+         fontname=None, fontsize=None, sysfontname=None,
+         antialias=True, bold=None, italic=None, underline=None,
+         color=None, background=None,
+         top=None, left=None, bottom=None, right=None,
+         topleft=None, bottomleft=None, topright=None, bottomright=None,
+         midtop=None, midleft=None, midbottom=None, midright=None,
+         center=None, centerx=None, centery=None,
+         width=None,	widthem=None, lineheight=None, strip=None,
+         align=None,
+         owidth=None, ocolor=None,
+         shadow=None, scolor=None,
+         gcolor=None,
+         alpha=1.0,
+         anchor=None,
+         angle=0,
+         surf=_default_surf_sentinel,
+         cache=True):
+
+    if topleft:
+        left, top = topleft
+    if bottomleft:
+        left, bottom = bottomleft
+    if topright:
+        right, top = topright
+    if bottomright:
+        right, bottom = bottomright
+    if midtop:
+        centerx, top = midtop
+    if midleft:
+        left, centery = midleft
+    if midbottom:
+        centerx, bottom = midbottom
+    if midright:
+        right, centery = midright
+    if center:
+        centerx, centery = center
+
+    x, y = pos or (None, None)
+    hanchor, vanchor = anchor or (None, None)
+    if left is not None:
+        x, hanchor = left, 0
+    if centerx is not None:
+        x, hanchor = centerx, 0.5
+    if right is not None:
+        x, hanchor = right, 1
+    if top is not None:
+        y, vanchor = top, 0
+    if centery is not None:
+        y, vanchor = centery, 0.5
+    if bottom is not None:
+        y, vanchor = bottom, 1
+    if x is None:
+        raise ValueError("Unable to determine horizontal position")
+    if y is None:
+        raise ValueError("Unable to determine vertical position")
+
+    if align is None:
+        align = hanchor
+    if hanchor is None:
+        hanchor = DEFAULT_ANCHOR[0]
+    if vanchor is None:
+        vanchor = DEFAULT_ANCHOR[1]
+
+    tsurf = getsurf(text, fontname, fontsize, sysfontname, bold, italic, underline, width, widthem,
+                    strip, color, background, antialias, ocolor, owidth, scolor, shadow, gcolor, alpha, align,
+                    lineheight, angle, cache)
+    angle = _resolveangle(angle)
+    if angle:
+        w0, h0 = _unrotated_size[(tsurf.get_size(), angle, text)]
+        S, C = sin(radians(angle)), cos(radians(angle))
+        dx, dy = (0.5 - hanchor) * w0, (0.5 - vanchor) * h0
+        x += dx * C + dy * S - 0.5 * tsurf.get_width()
+        y += -dx * S + dy * C - 0.5 * tsurf.get_height()
+    else:
+        x -= hanchor * tsurf.get_width()
+        y -= vanchor * tsurf.get_height()
+    x = int(round(x))
+    y = int(round(y))
+
+    if surf is _default_surf_sentinel:
+        surf = pygame.display.get_surface()
+    if surf is not None:
+        surf.blit(tsurf, (x, y))
+
+    if AUTO_CLEAN:
+        clean()
+
+    return tsurf, (x, y)
+
+
+def drawbox(text, rect, fontname=None, sysfontname=None, lineheight=None, anchor=None,
+            bold=None, italic=None, underline=None, strip=None, **kwargs):
+    if fontname is None:
+        fontname = DEFAULT_FONT_NAME
+    if lineheight is None:
+        lineheight = DEFAULT_LINE_HEIGHT
+    hanchor, vanchor = anchor = anchor or (0.5, 0.5)
+    rect = pygame.Rect(rect)
+    x = rect.x + hanchor * rect.width
+    y = rect.y + vanchor * rect.height
+    fontsize = _fitsize(text, fontname, sysfontname, bold, italic, underline,
+                        rect.width, rect.height, lineheight, strip)
+    return draw(text, (x, y), fontname=fontname, fontsize=fontsize, lineheight=lineheight,
+                width=rect.width, strip=strip, anchor=anchor, **kwargs)
+
+
+def clean():
+    global _surf_size_total
+    memory_limit = MEMORY_LIMIT_MB * (1 << 20)
+    if _surf_size_total < memory_limit:
+        return
+    memory_limit *= MEMORY_REDUCTION_FACTOR
+    keys = sorted(_surf_cache, key=_surf_tick_usage.get)
+    for key in keys:
+        w, h = _surf_cache[key].get_size()
+        del _surf_cache[key]
+        del _surf_tick_usage[key]
+        _surf_size_total -= 4 * w * h
+        if _surf_size_total < memory_limit:
+            break