[justify] Add demo GTK app

src/justify.py

@@ -0,0 +1,364 @@
+import gi
+
+from collections import namedtuple
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, HarfBuzz as hb
+
+
+POOL = {}
+
+
+def move_to_f(funcs, draw_data, st, to_x, to_y, user_data):
+    context = POOL[draw_data]
+    context.move_to(to_x, to_y)
+
+
+def line_to_f(funcs, draw_data, st, to_x, to_y, user_data):
+    context = POOL[draw_data]
+    context.line_to(to_x, to_y)
+
+
+def cubic_to_f(
+    funcs,
+    draw_data,
+    st,
+    control1_x,
+    control1_y,
+    control2_x,
+    control2_y,
+    to_x,
+    to_y,
+    user_data,
+):
+    context = POOL[draw_data]
+    context.curve_to(control1_x, control1_y, control2_x, control2_y, to_x, to_y)
+
+
+def close_path_f(funcs, draw_data, st, user_data):
+    context = POOL[draw_data]
+    context.close_path()
+
+
+DFUNCS = hb.draw_funcs_create()
+hb.draw_funcs_set_move_to_func(DFUNCS, move_to_f, None)
+hb.draw_funcs_set_line_to_func(DFUNCS, line_to_f, None)
+hb.draw_funcs_set_cubic_to_func(DFUNCS, cubic_to_f, None)
+hb.draw_funcs_set_close_path_func(DFUNCS, close_path_f, None)
+
+
+def push_transform_f(funcs, paint_data, xx, yx, xy, yy, dx, dy, user_data):
+    raise NotImplementedError
+
+
+def pop_transform_f(funcs, paint_data, user_data):
+    raise NotImplementedError
+
+
+def color_f(funcs, paint_data, is_foreground, color, user_data):
+    context = POOL[paint_data]
+    r = hb.color_get_red(color) / 255
+    g = hb.color_get_green(color) / 255
+    b = hb.color_get_blue(color) / 255
+    a = hb.color_get_alpha(color) / 255
+    context.set_source_rgba(r, g, b, a)
+    context.paint()
+
+
+def push_clip_rectangle_f(funcs, paint_data, xmin, ymin, xmax, ymax, user_data):
+    context = POOL[paint_data]
+    context.save()
+    context.rectangle(xmin, ymin, xmax, ymax)
+    context.clip()
+
+
+def push_clip_glyph_f(funcs, paint_data, glyph, font, user_data):
+    context = POOL[paint_data]
+    context.save()
+    context.new_path()
+    hb.font_draw_glyph(font, glyph, DFUNCS, paint_data)
+    context.close_path()
+    context.clip()
+
+
+def pop_clip_f(funcs, paint_data, user_data):
+    context = POOL[paint_data]
+    context.restore()
+
+
+def push_group_f(funcs, paint_data, user_data):
+    raise NotImplementedError
+
+
+def pop_group_f(funcs, paint_data, mode, user_data):
+    raise NotImplementedError
+
+
+PFUNCS = hb.paint_funcs_create()
+hb.paint_funcs_set_push_transform_func(PFUNCS, push_transform_f, None)
+hb.paint_funcs_set_pop_transform_func(PFUNCS, pop_transform_f, None)
+hb.paint_funcs_set_color_func(PFUNCS, color_f, None)
+hb.paint_funcs_set_push_clip_glyph_func(PFUNCS, push_clip_glyph_f, None)
+hb.paint_funcs_set_push_clip_rectangle_func(PFUNCS, push_clip_rectangle_f, None)
+hb.paint_funcs_set_pop_clip_func(PFUNCS, pop_clip_f, None)
+hb.paint_funcs_set_push_group_func(PFUNCS, push_group_f, None)
+hb.paint_funcs_set_pop_group_func(PFUNCS, pop_group_f, None)
+
+
+class Word:
+    def __init__(self, font, text):
+        self._text = text
+        self._font = font
+        self._glyphs = []
+        self._positions = []
+
+    def append(self, info, pos):
+        self._glyphs.append(info)
+        self._positions.append(pos)
+
+    def draw(self, context, font):
+        for info, pos in zip(self._glyphs, self._positions):
+            context.translate(-pos.x_advance, pos.y_advance)
+            context.save()
+            context.translate(pos.x_offset, pos.y_offset)
+            hb.font_paint_glyph(font, info.codepoint, PFUNCS, id(context), 0, 0x0000FF)
+            context.restore()
+
+    @property
+    def advance(self):
+        return sum(pos.x_advance for pos in self._positions)
+
+    @property
+    def strippedadvance(self):
+        w = self.advance
+        if len(self) and self._text[self._glyphs[-1].cluster] == " ":
+            w -= self._positions[-1].x_advance
+        return w
+
+    def __str__(self):
+        if not self._glyphs:
+            return ""
+        first = min(g.cluster for g in self._glyphs)
+        last = max(g.cluster for g in self._glyphs)
+        return self._text[first : last + 1]
+
+    def __len__(self):
+        return len(self._glyphs)
+
+    def __bool__(self):
+        return len(self) != 0
+
+    def __repr__(self):
+        return f"<Word advance={self.advance} text='{str(self)}'>"
+
+
+class Line:
+    def __init__(self, font, target_advance):
+        self._font = font
+        self._target_advance = target_advance
+        self._words = []
+        self._variation = None
+
+    def append(self, word):
+        self._words.append(word)
+
+    def pop(self):
+        return self._words.pop()
+
+    def justify(self):
+        buf, text = makebuffer(str(self))
+
+        advance = self.advance
+        shrink = self._target_advance > advance
+        expand = not shrink
+
+        ret, advance, tag, value = hb.shape_justify(
+            self._font,
+            buf,
+            None,
+            None,
+            self._target_advance,
+            self._target_advance,
+            advance,
+        )
+
+        if not ret:
+            return False
+        if shrink and advance > self._target_advance:
+            return False
+        if expand and advance < self._target_advance:
+            return False
+
+        self._variation = hb.variation_t()
+        self._variation.tag = tag
+        self._variation.value = value
+        self._words = makewords(buf, self._font, text)
+        return True
+
+    def draw(self, context):
+        context.save()
+        context.move_to(-1600, -200)
+        context.set_font_size(130)
+        context.set_source_rgb(1, 0, 0)
+        if self._variation:
+            tag = hb.tag_to_string(self._variation.tag).decode("ascii")
+            context.show_text(f" {tag}={self._variation.value:g}")
+        context.move_to(-1600, 0)
+        context.show_text(f" {self.advance:g}/{self._target_advance:g}")
+        context.restore()
+
+        if self._variation:
+            hb.font_set_variations(self._font, [self._variation])
+
+        context.scale(1, -1)
+        context.translate(self._target_advance, 0)
+        for word in self._words:
+            word.draw(context, self._font)
+
+    @property
+    def advance(self):
+        w = sum(word.advance for word in self._words[:-1])
+        if len(self):
+            w += self._words[-1].strippedadvance
+        return w
+
+    def __str__(self):
+        return "".join(str(w) for w in self._words)
+
+    def __len__(self):
+        return len(self._words)
+
+    def __bool__(self):
+        return len(self) != 0
+
+    def __repr__(self):
+        return f"<Line advance={self.advance} text='{str(self)}'>"
+
+
+Configuration = namedtuple(
+    "Configuration", ["width", "height", "fontsize", "fontpath", "textpath"]
+)
+
+
+def makebuffer(text):
+    buf = hb.buffer_create()
+    hb.buffer_set_direction(buf, hb.direction_t.RTL)
+    hb.buffer_set_script(buf, hb.script_t.ARABIC)
+    hb.buffer_set_language(buf, hb.language_from_string(b"ar"))
+
+    # Strip and remove double spaces.
+    text = " ".join(text.split())
+
+    hb.buffer_add_codepoints(buf, [ord(c) for c in text], 0, len(text))
+
+    return buf, text
+
+
+def makewords(buf, font, text):
+    hb.buffer_reverse(buf)
+    words = [Word(font, text)]
+    infos = hb.buffer_get_glyph_infos(buf)
+    positions = hb.buffer_get_glyph_positions(buf)
+    for info, pos in zip(infos, positions):
+        words[-1].append(info, pos)
+        if text[info.cluster] == " ":
+            words.append(Word(font, text))
+    return words
+
+
+def typeset(conf):
+    blob = hb.blob_create_from_file(conf.fontpath)
+    face = hb.face_create(blob, 0)
+    font = hb.font_create(face)
+
+    with open(conf.textpath) as f:
+        text = f.read()
+
+    margin = conf.fontsize * 2
+    scale = conf.fontsize / hb.face_get_upem(face)
+    target_advance = (conf.width - (margin * 2)) / scale
+
+    buf, text = makebuffer(text)
+
+    hb.shape(font, buf)
+
+    words = makewords(buf, font, text)
+
+    lines = [Line(font, target_advance)]
+
+    for word in words:
+        lines[-1].append(word)
+        if lines[-1].advance > target_advance:
+            if lines[-1].justify():
+                # Shrink
+                lines.append(Line(font, target_advance))
+            else:
+                # Remove last word and expand
+                lines[-1].pop()
+                lines[-1].justify()
+                lines.append(Line(font, target_advance))
+                lines[-1].append(word)
+
+    if lines[-1].advance != target_advance:
+        lines[-1].justify()
+
+    return lines, font
+
+
+def render(context, conf):
+    lines, font = typeset(conf)
+
+    margin = conf.fontsize * 2
+    scale = conf.fontsize / hb.face_get_upem(hb.font_get_face(font))
+
+    _, extents = hb.font_get_h_extents(font)
+    lineheight = extents.ascender - extents.descender + extents.line_gap
+    lineheight *= scale
+
+    context.save()
+    context.translate(0, margin)
+    for line in lines:
+        context.translate(0, lineheight)
+
+        context.save()
+        context.translate(margin, 0)
+        context.scale(scale, scale)
+        line.draw(context)
+        context.restore()
+    context.restore()
+
+
+def main(fontpath, textpath):
+    def on_draw(da, context):
+        alloc = da.get_allocation()
+        conf = Configuration(
+            width=alloc.width,
+            height=alloc.height,
+            fontsize=70,
+            fontpath=fontpath,
+            textpath=textpath,
+        )
+        POOL[id(context)] = context
+        render(context, conf)
+        del POOL[id(context)]
+
+    drawingarea = Gtk.DrawingArea()
+    drawingarea.connect("draw", on_draw)
+
+    win = Gtk.Window()
+    win.connect("destroy", Gtk.main_quit)
+    win.set_default_size(1000, 700)
+    win.add(drawingarea)
+
+    win.show_all()
+    Gtk.main()
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="HarfBuzz justification demo.")
+    parser.add_argument("fontfile", help="input Glyphs source file")
+    parser.add_argument("textfile", help="font version")
+    args = parser.parse_args()
+    main(args.fontfile, args.textfile)