Underlines for left-aligned text

Author: camelpunch

lib/mudbrick.ex

@@ -236,6 +236,20 @@ defmodule Mudbrick do
       ...> new(fonts: %{regular: [file: bodoni_regular()], bold: [file: bodoni_bold()]})
       ...> |> page()
       ...> |> text(["I am ", {"bold", font: :bold}], font: :regular, position: {200, 200})
+
+  Underlined text.
+
+      iex> import Mudbrick.TestHelper
+      ...> import Mudbrick
+      ...> new(fonts: %{bodoni: [file: bodoni_regular()]})
+      ...> |> page(size: {100, 40})
+      ...> |> text(["nounderline\\n", {"underline!", underline: [width: 1]}], position: {8, 20}, font: :bodoni, font_size: 8)
+      ...> |> render()
+      ...> |> then(&File.write("examples/underlined_text.pdf", &1))
+
+  Produces [this PDF](examples/underlined_text.pdf?#navpanes=0).
+
+  <object width="400" height="115" data="examples/underlined_text.pdf?#navpanes=0" type="application/pdf"></object>
   """
 
   @spec text(context(), Mudbrick.TextBlock.write(), Mudbrick.TextBlock.options()) :: context()
@@ -256,7 +270,7 @@ defmodule Mudbrick do
 
     context
     |> ContentStream.update_operations(fn ops ->
-      Enum.reverse(TextBlock.Output.from(text_block).operations) ++ ops
+      TextBlock.Output.from(text_block).operations ++ ops
     end)
   end
 

lib/mudbrick/text_block.ex

@@ -1,6 +1,11 @@
 defmodule Mudbrick.TextBlock do
   @type alignment :: :left | :right
 
+  @type underline_option ::
+          {:width, number()}
+          | {:colour, Mudbrick.colour()}
+  @type underline_options :: [underline_option()]
+
   @type option ::
           {:align, alignment()}
           | {:colour, Mudbrick.colour()}
@@ -16,6 +21,7 @@ defmodule Mudbrick.TextBlock do
           | {:font, atom()}
           | {:font_size, number()}
           | {:leading, number()}
+          | {:underline, underline_options()}
 
   @type part_options :: [part_option()]
 
@@ -40,9 +46,9 @@ defmodule Mudbrick.TextBlock do
             colour: {0, 0, 0},
             font: nil,
             font_size: 12,
+            leading: nil,
             lines: [],
-            position: {0, 0},
-            leading: nil
+            position: {0, 0}
 
   alias Mudbrick.TextBlock.Line
 

lib/mudbrick/text_block/line.ex

@@ -17,7 +17,8 @@ defmodule Mudbrick.TextBlock.Line do
               font: nil,
               font_size: nil,
               left_offset: nil,
-              text: ""
+              text: "",
+              underline: nil
 
     def width(part) do
       Mudbrick.Font.width(

lib/mudbrick/text_block/output.ex

@@ -1,27 +1,29 @@
 defmodule Mudbrick.TextBlock.Output do
   @moduledoc false
 
-  defstruct font: nil, font_size: nil, operations: []
+  defstruct position: nil,
+            font: nil,
+            font_size: nil,
+            operations: [],
+            drawings: []
 
   alias Mudbrick.ContentStream.{BT, ET}
   alias Mudbrick.ContentStream.Rg
   alias Mudbrick.ContentStream.Td
   alias Mudbrick.ContentStream.Tf
   alias Mudbrick.ContentStream.{Apostrophe, Tj}
   alias Mudbrick.ContentStream.TL
+  alias Mudbrick.Path
   alias Mudbrick.TextBlock.Line
 
   defmodule LeftAlign do
     @moduledoc false
 
     alias Mudbrick.TextBlock.Output
 
-    defp leading(output, %Line{leading: nil}) do
-      output
-    end
-
     defp leading(output, line) do
-      Output.add(output, %TL{leading: line.leading})
+      output
+      |> Output.add(%TL{leading: line.leading})
     end
 
     def reduce_lines(output, [line]) do
@@ -42,7 +44,9 @@ defmodule Mudbrick.TextBlock.Output do
     end
 
     defp reduce_parts(output, %Line{parts: [part]}, _operator, :first_line) do
-      Output.add_part(output, part, Tj)
+      output
+      |> Output.add_part(part, Tj)
+      |> underline(part)
     end
 
     defp reduce_parts(output, %Line{parts: []}, _operator, nil) do
@@ -52,13 +56,40 @@ defmodule Mudbrick.TextBlock.Output do
 
     defp reduce_parts(output, %Line{parts: [part]}, _operator, nil) do
       Output.add_part(output, part, Apostrophe)
+      |> underline(part)
     end
 
     defp reduce_parts(output, %Line{parts: [part | parts]} = line, operator, line_kind) do
       output
       |> Output.add_part(part, operator)
+      |> underline(part)
       |> reduce_parts(%{line | parts: parts}, Tj, line_kind)
     end
+
+    defp underline(output, part) do
+      output
+      |> then(fn output ->
+        if part.underline do
+          {x, y} = output.position
+          {offset_x, offset_y} = part.left_offset
+
+          x = x + offset_x
+          y = y + offset_y - 2
+
+          path_output =
+            Path.new()
+            |> Path.move(to: {x, y})
+            |> Path.line(to: {x + Line.Part.width(part), y})
+            |> Path.Output.from()
+
+          Map.update!(output, :drawings, fn drawings ->
+            [path_output | drawings]
+          end)
+        else
+          output
+        end
+      end)
+    end
   end
 
   defmodule RightAlign do
@@ -98,26 +129,37 @@ defmodule Mudbrick.TextBlock.Output do
     end
   end
 
+  defp drawings(output) do
+    Map.update!(output, :operations, fn ops ->
+      for drawing <- output.drawings, reduce: ops do
+        ops ->
+          Enum.reverse(drawing.operations) ++ ops
+      end
+    end)
+  end
+
   def from(
         %Mudbrick.TextBlock{
           align: :left,
           font: font,
           font_size: font_size,
-          position: {x, y}
+          position: position = {x, y}
         } = tb
       ) do
     tl = %TL{leading: leading(tb)}
     tf = %Tf{font: font, size: font_size}
 
-    %__MODULE__{font: font, font_size: font_size}
+    %__MODULE__{position: position, font: font, font_size: font_size}
     |> end_block()
     |> LeftAlign.reduce_lines(tb.lines)
     |> add(%Td{tx: x, ty: y})
     |> add(tl)
     |> add(tf)
     |> start_block()
+    |> drawings()
     |> deduplicate(tl)
     |> deduplicate(tf)
+    |> Map.update!(:operations, &Enum.reverse/1)
   end
 
   def from(
@@ -136,6 +178,7 @@ defmodule Mudbrick.TextBlock.Output do
     |> add(%TL{leading: leading(tb)})
     |> add(tf)
     |> deduplicate(tf)
+    |> Map.update!(:operations, &Enum.reverse/1)
   end
 
   def add(%__MODULE__{} = output, op) do
@@ -145,21 +188,17 @@ defmodule Mudbrick.TextBlock.Output do
   def add_part(output, part, operator) do
     output
     |> with_font(
-      struct!(operator, font: part.font || output.font, text: part.text),
+      struct!(operator, font: part.font, text: part.text),
       part
     )
     |> colour(part.colour)
   end
 
   def with_font(output, op, part) do
-    if part.font in [nil, output.font] and part.font_size == nil do
-      add(output, op)
-    else
-      output
-      |> add(%Tf{font: output.font, size: output.font_size})
-      |> add(op)
-      |> add(%Tf{font: part.font || output.font, size: part.font_size || output.font_size})
-    end
+    output
+    |> add(%Tf{font: output.font, size: output.font_size})
+    |> add(op)
+    |> add(%Tf{font: part.font, size: part.font_size})
   end
 
   def colour(output, {r, g, b}) do

test/mudbrick/text_block_test.exs

@@ -135,6 +135,34 @@ defmodule Mudbrick.TextBlockTest do
            ] = block.lines
   end
 
+  describe "underline" do
+    test "can be set on a single line" do
+      block =
+        TextBlock.new(
+          font_size: 10,
+          position: {400, 500}
+        )
+        |> TextBlock.write("this is ")
+        |> TextBlock.write("underlined", underline: [width: 1])
+
+      assert block.lines == [
+               %Line{
+                 leading: 12,
+                 parts: [
+                   %Part{
+                     colour: {0, 0, 0},
+                     font: nil,
+                     font_size: 10,
+                     text: "underlined",
+                     underline: [width: 1]
+                   },
+                   %Part{colour: {0, 0, 0}, font: nil, font_size: 10, text: "this is "}
+                 ]
+               }
+             ]
+    end
+  end
+
   describe "leading" do
     test "can be set per line" do
       block =
@@ -267,6 +295,41 @@ defmodule Mudbrick.TextBlockTest do
                end)
                |> operations()
     end
+
+    test "underlines happen" do
+      assert [
+               "q",
+               "0.0 469.2 m",
+               "0 0 0 RG",
+               "1 w",
+               "91.53599999999999 469.2 l",
+               "S",
+               "Q",
+               "q",
+               "0.0 498.0 m",
+               "0 0 0 RG",
+               "1 w",
+               "62.064 498.0 l",
+               "S",
+               "Q",
+               "BT",
+               "/F1 12 Tf",
+               "14.399999999999999 TL",
+               "0 500 Td",
+               "0 0 0 rg",
+               "<012100F400BB00C0010F00ED00D900F400C000BB01B7> Tj",
+               "<00F400FC011D01B7012100F400BB00C0010F00ED00D900F400C000BB01B7> '",
+               "<012100F400BB00C0010F00ED00D900F400C000BB01B700A500CF00A500D900F4> '",
+               "ET"
+             ] =
+               output(fn %{fonts: fonts} ->
+                 TextBlock.new(font: fonts.regular, position: {0, 500})
+                 |> TextBlock.write("underlined ", underline: [width: 1])
+                 |> TextBlock.write("\nnot underlined ")
+                 |> TextBlock.write("\nunderlined again", underline: [width: 1])
+               end)
+               |> operations()
+    end
   end
 
   describe "right-aligned" do
@@ -387,7 +450,9 @@ defmodule Mudbrick.TextBlockTest do
     end
   end
 
-  defp output(f), do: output(f, Mudbrick.TextBlock.Output)
+  defp output(f) do
+    output(f, Mudbrick.TextBlock.Output) |> Enum.reverse()
+  end
 
   defp operations(ops) do
     Enum.map(ops, &Mudbrick.TestHelper.show/1)