Define ParsedText to hold line parsing results

Author: serenity4

src/OpenType.jl

@@ -15,6 +15,7 @@ using .Meta: isexpr
 
 const Vec = SVector
 const Vec2 = SVector{2,Float64}
+const Box2 = Box{2,Float64}
 
 @reexport import GeometryExperiments: boundingelement
 @reexport using BinaryParsingTools: Tag, @tag_str, @tag2_str, @tag3_str, @tag4_str, Tag2, Tag3, Tag4
@@ -88,9 +89,8 @@ export GlyphID,
 
   Line, LineSegment,
   ascender, descender,
-  segment_geometry, segment_height, line_geometry, text_geometry,
-  has_outlines,
-  lines,
+  segment_geometry, segment_height, line_geometry,
+  has_outlines, ParsedText,
   GlyphStyle
 
 end

src/text.jl

@@ -250,14 +250,39 @@ end
 
 Base.show(io::IO, line::Line) = print(io, Line, '(', length(line.glyphs), " glyphs, ", length(line.segments), " segments)")
 
+struct ParsedText
+  lines::Vector{Line}
+  spacings::Vector{Float64}
+  geometry::Optional{Box2}
+end
+
+function ParsedText(text::Text, fonts)
+  lines = parse_lines(text, fonts)
+  spacings = compute_line_spacings(lines, text.options)
+  geometry = compute_text_geometry(text, lines, spacings)
+  return ParsedText(lines, spacings, geometry)
+end
+
+function compute_line_spacings(lines, options::TextOptions)
+  spacings = Float64[0.0]
+  for i in eachindex(lines)[begin:(end - 1)]
+    prev = lines[i]
+    next = lines[i + 1]
+    height = ascender(next) - descender(prev)
+    spacing = height * options.line_spacing
+    push!(spacings, spacing)
+  end
+  return spacings
+end
+
 function segment_geometry(line::Line, segment::LineSegment)
   isempty(segment.indices) && return nothing
   ymin = descender(segment)
   ymax = ascender(segment)
   xmin, _ = line.positions[first(segment.indices)]
   width = sum(first, @view line.advances[segment.indices]; init = 0.0)
   xmax = xmin + width
-  Box(Point2(xmin, ymin), Point2(xmax, ymax))
+  return Box(Point2(xmin, ymin), Point2(xmax, ymax))
 end
 
 function line_geometry(line::Line)
@@ -267,7 +292,7 @@ function line_geometry(line::Line)
   ymax = ascender(line)
   width = sum(first, line.advances; init = 0.0)
   xmax = xmin + width
-  Box(Point2(xmin, ymin), Point2(xmax, ymax))
+  return Box(Point2(xmin, ymin), Point2(xmax, ymax))
 end
 
 function has_outlines(line::Line, segment::LineSegment)
@@ -277,29 +302,28 @@ function has_outlines(line::Line, segment::LineSegment)
     outlines = line.outlines[glyph]
     !isempty(outlines) && return true
   end
-  false
+  return false
 end
 
 ascender(line::Line) = maximum(ascender, line.segments; init = 0.0)
 descender(line::Line) = maximum(descender, line.segments; init = 0.0)
 
-function split_lines(text::Text)
+function split_text_into_lines(text::Text)
   newlines = findall(==('\n'), text.chars)
   push!(newlines, 1 + lastindex(text.chars))
   lines = SplitLine[]
   prev = 0
   for i in newlines
     range = (prev + 1):(i - 1)
     prev = i
-    isempty(range) && continue
     push!(lines, SplitLine(text.chars[range], range.start, text.style_changes))
   end
-  lines
+  return lines
 end
 
-function lines(text::Text, fonts::AbstractVector{Pair{OpenTypeFont, FontOptions}})
+function parse_lines(text::Text, fonts::AbstractVector{Pair{OpenTypeFont, FontOptions}})
   lines = Line[]
-  for line in split_lines(text)
+  for line in split_text_into_lines(text)
     glyph_indices = Dict{Pair{GlyphID, OpenTypeFont}, Int64}()
     line_glyphs, line_positions, line_advances = GlyphID[], Vec2[], Vec2[]
     outlines = Vector{GlyphOutline}[]
@@ -327,7 +351,7 @@ function lines(text::Text, fonts::AbstractVector{Pair{OpenTypeFont, FontOptions}
     end
     push!(lines, Line(line_glyphs, line_positions, line_advances, segments, outlines))
   end
-  lines
+  return lines
 end
 
 function compute_positions(offsets, start, scale)
@@ -336,19 +360,15 @@ function compute_positions(offsets, start, scale)
     push!(positions, start .+ offset.origin .* scale)
     start = start .+ offset.advance .* scale
   end
-  positions
+  return positions
 end
 
-text_geometry(text::Text, fonts) = text_geometry(text, lines(text, fonts))
-
-function text_geometry(text::Text, lines::AbstractVector{Line})
+function compute_text_geometry(text::Text, lines::AbstractVector{Line}, spacings::Vector{Float64})
   result = nothing
-  for line in lines
+  for (line, spacing) in zip(lines, spacings)
     geometry = line_geometry(line)
-    if !isnothing(result)
-      geometry -= Vec2(0.0, text.options.line_spacing * result.height)
-    end
-    result = isnothing(result) ? geometry : boundingelement(result, geometry)
+    geometry === nothing && continue
+    result = result == nothing ? geometry : boundingelement(result, @set geometry -= Vec2(0, spacing))
   end
-  result
+  return result
 end

test/text.jl

@@ -63,24 +63,23 @@
   file = google_font_files["inter"][1]
   font = OpenTypeFont(file);
   options = FontOptions(ShapingOptions(tag"latn", tag"fra "), FontSize(1/10; reduce_to_fit = false))
-  t = Text("The brown fox jumps over the lazy dog.", TextOptions())
-  ls = lines(t, [font => options])
-  @test length(ls) == 1
-  line = ls[1]
-  @test length(line.glyphs) == length(t.chars)
+  text = Text("The brown fox jumps over the lazy dog.", TextOptions())
+  parsed = ParsedText(text, [font => options])
+  @test length(parsed.lines) == 1
+  line = parsed.lines[1]
+  @test length(line.glyphs) == length(text.chars)
   @test length(line.segments) == 1
   segment = line.segments[1]
   @test sprint(show, MIME"text/plain"(), segment) isa String
-  @test segment.indices == eachindex(t.chars)
-  box = text_geometry(t, [font => options])
-  @test box.min === Point2(0, 0)
-  @test 1.82 < box.max[1] < 1.83
-  @test 0.096 < box.max[2] < 0.097
+  @test segment.indices == eachindex(text.chars)
+  @test parsed.geometry.min === Point2(0, 0)
+  @test 1.82 < parsed.geometry.max[1] < 1.83
+  @test 0.096 < parsed.geometry.max[2] < 0.097
 
-  t = Text(styled"The {bold:brown} {red:fox {italic:jumps}} over the {italic:lazy} dog.", TextOptions())
-  box2 = text_geometry(t, [font => options])
-  @test box == box2
-  line = only(lines(t, [font => options]))
+  text = Text(styled"The {bold:brown} {red:fox {italic:jumps}} over the {italic:lazy} dog.", TextOptions())
+  parsed2 = ParsedText(text, [font => options])
+  @test parsed.geometry == parsed2.geometry
+  line = only(parsed2.lines)
   @test length(line.segments) == 8
   a, b, c, d, e, f, g, h = line.segments
   test_style_equals(x, y) = for prop in fieldnames(GlyphStyle); prop ≠ :size && @test getproperty(x, prop) == getproperty(y, prop); end
@@ -98,8 +97,9 @@
 
   file = google_font_files["spacemono"][1]
   font = OpenTypeFont(file);
-  t = Text(styled"{size=20:Some{size=100: big }text.}", TextOptions())
-  line = only(lines(t, [font => options]))
+  text = Text(styled"{size=20:Some{size=100: big }text.}", TextOptions())
+  parsed = ParsedText(text, [font => options])
+  line = only(parsed.lines)
   @test length(line.segments) == 3
   a, b, c = line.segments
   @test a.style.size === c.style.size