summaryrefslogtreecommitdiff
path: root/poezio/windows/image.py
blob: dfd2eae2a985830eee9eda7465f33533bc3b0b17 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
"""
Defines a window which contains either an image or a border.
"""

import curses
from io import BytesIO

try:
    from PIL import Image
    HAS_PIL = True
except ImportError:
    class Image:
        class Image:
            pass
    HAS_PIL = False

try:
    import gi
    gi.require_version('Rsvg', '2.0')
    from gi.repository import Rsvg
    import cairo
    HAS_RSVG = True
except (ImportError, ValueError):
    HAS_RSVG = False

from poezio.windows.base_wins import Win
from poezio.theming import get_theme, to_curses_attr
from poezio.xhtml import _parse_css_color
from poezio.config import config

from typing import Tuple, Optional, Callable


MAX_SIZE = 16


def render_svg(svg: bytes) -> Optional[Image.Image]:
    if not HAS_RSVG:
        return None
    try:
        handle = Rsvg.Handle.new_from_data(svg)
        dimensions = handle.get_dimensions()
        biggest_dimension = max(dimensions.width, dimensions.height)
        scale = MAX_SIZE / biggest_dimension
        translate_x = (biggest_dimension - dimensions.width) / 2
        translate_y = (biggest_dimension - dimensions.height) / 2

        surface = cairo.ImageSurface(cairo.Format.ARGB32, MAX_SIZE, MAX_SIZE)
        context = cairo.Context(surface)
        context.scale(scale, scale)
        context.translate(translate_x, translate_y)
        handle.render_cairo(context)
        data = surface.get_data()
        image = Image.frombytes('RGBA', (MAX_SIZE, MAX_SIZE), data.tobytes())
        # This is required because Cairo uses a BGRA (in host endianness)
        # format, and PIL an ABGR (in byte order) format.  Yes, this is
        # confusing.
        b, g, r, a = image.split()
        return Image.merge('RGB', (r, g, b))
    except Exception:
        return None


class ImageWin(Win):
    """
    A window which contains either an image or a border.
    """

    __slots__ = ('_image', '_display_avatar')

    def __init__(self) -> None:
        self._image = None  # type: Optional[Image.Image]
        Win.__init__(self)
        if config.get('image_use_half_blocks'):
            self._display_avatar = self._display_avatar_half_blocks  # type: Callable[[int, int], None]
        else:
            self._display_avatar = self._display_avatar_full_blocks

    def resize(self, height: int, width: int, y: int, x: int) -> None:
        self._resize(height, width, y, x)
        if self._image is None:
            return
        self._display_avatar(width, height)

    def refresh(self, data: Optional[bytes]) -> None:
        self._win.erase()
        if data is not None and HAS_PIL:
            image_file = BytesIO(data)
            try:
                try:
                    image = Image.open(image_file)
                except OSError:
                    # TODO: Make the caller pass the MIME type, so we don’t
                    # have to try all renderers like that.
                    image = render_svg(data)
                    if image is None:
                        raise
            except OSError:
                self._display_border()
            else:
                self._image = image.convert('RGB')
                self._display_avatar(self.width, self.height)
        else:
            self._display_border()
        self._refresh()

    def _display_border(self) -> None:
        self._image = None
        attribute = to_curses_attr(get_theme().COLOR_VERTICAL_SEPARATOR)
        self._win.attron(attribute)
        self._win.border(curses.ACS_VLINE, curses.ACS_VLINE, curses.ACS_HLINE,
                         curses.ACS_HLINE, curses.ACS_ULCORNER,
                         curses.ACS_URCORNER, curses.ACS_LLCORNER,
                         curses.ACS_LRCORNER)
        self._win.attroff(attribute)

    @staticmethod
    def _compute_size(image_size: Tuple[int, int], width: int, height: int) -> Tuple[int, int]:
        height *= 2
        src_width, src_height = image_size
        ratio = src_width / src_height
        new_width = height * ratio
        new_height = width / ratio
        if new_width > width:
            height = int(new_height)
        elif new_height > height:
            width = int(new_width)
        return width, height

    def _display_avatar_half_blocks(self, width: int, height: int) -> None:
        if self._image is None:
            return
        original_height = height
        original_width = width
        size = self._compute_size(self._image.size, width, height)
        image2 = self._image.resize(size, resample=Image.BILINEAR)
        data = image2.tobytes()
        width, height = size
        start_y = (original_height - height // 2) // 2
        start_x = (original_width - width) // 2
        for y in range(height // 2):
            two_lines = data[(2 * y) * width * 3:(2 * y + 2) * width * 3]
            line1 = two_lines[:width * 3]
            line2 = two_lines[width * 3:]
            self.move(start_y + y, start_x)
            for x in range(0, width * 3, 3):
                r, g, b = line1[x:x + 3]
                top_color = _parse_css_color('#%02x%02x%02x' % (r, g, b))
                r, g, b = line2[x:x + 3]
                bot_color = _parse_css_color('#%02x%02x%02x' % (r, g, b))
                self.addstr('▄', to_curses_attr((bot_color, top_color)))

    def _display_avatar_full_blocks(self, width: int, height: int) -> None:
        if self._image is None:
            return
        original_height = height
        original_width = width
        width, height = self._compute_size(self._image.size, width, height)
        height //= 2
        size = width, height
        image2 = self._image.resize(size, resample=Image.BILINEAR)
        data = image2.tobytes()
        start_y = (original_height - height) // 2
        start_x = (original_width - width) // 2
        for y in range(height):
            line = data[y * width * 3:(y + 1) * width * 3]
            self.move(start_y + y, start_x)
            for x in range(0, width * 3, 3):
                r, g, b = line[x:x + 3]
                color = _parse_css_color('#%02x%02x%02x' % (r, g, b))
                self.addstr('█', to_curses_attr((color, -1)))