fillform 0.1.0

data/data/agl/zapfdingbats.txt

@@ -0,0 +1,245 @@
+# -----------------------------------------------------------
+# Copyright 2002-2019 Adobe (http://www.adobe.com/).
+#
+# Redistribution and use in source and binary forms, with or
+# without modification, are permitted provided that the
+# following conditions are met:
+#
+# Redistributions of source code must retain the above
+# copyright notice, this list of conditions and the following
+# disclaimer.
+#
+# Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following
+# disclaimer in the documentation and/or other materials
+# provided with the distribution.
+#
+# Neither the name of Adobe nor the names of its contributors
+# may be used to endorse or promote products derived from this
+# software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------
+# Name:          ITC Zapf Dingbats Glyph List
+# Table version: 2.0
+# Date:          September 20, 2002
+# URL:           https://github.com/adobe-type-tools/agl-aglfn
+#
+# Format: two semicolon-delimited fields:
+#   (1) glyph name--upper/lowercase letters and digits
+#   (2) Unicode scalar value--four uppercase hexadecimal digits
+#
+a100;275E
+a101;2761
+a102;2762
+a103;2763
+a104;2764
+a105;2710
+a106;2765
+a107;2766
+a108;2767
+a109;2660
+a10;2721
+a110;2665
+a111;2666
+a112;2663
+a117;2709
+a118;2708
+a119;2707
+a11;261B
+a120;2460
+a121;2461
+a122;2462
+a123;2463
+a124;2464
+a125;2465
+a126;2466
+a127;2467
+a128;2468
+a129;2469
+a12;261E
+a130;2776
+a131;2777
+a132;2778
+a133;2779
+a134;277A
+a135;277B
+a136;277C
+a137;277D
+a138;277E
+a139;277F
+a13;270C
+a140;2780
+a141;2781
+a142;2782
+a143;2783
+a144;2784
+a145;2785
+a146;2786
+a147;2787
+a148;2788
+a149;2789
+a14;270D
+a150;278A
+a151;278B
+a152;278C
+a153;278D
+a154;278E
+a155;278F
+a156;2790
+a157;2791
+a158;2792
+a159;2793
+a15;270E
+a160;2794
+a161;2192
+a162;27A3
+a163;2194
+a164;2195
+a165;2799
+a166;279B
+a167;279C
+a168;279D
+a169;279E
+a16;270F
+a170;279F
+a171;27A0
+a172;27A1
+a173;27A2
+a174;27A4
+a175;27A5
+a176;27A6
+a177;27A7
+a178;27A8
+a179;27A9
+a17;2711
+a180;27AB
+a181;27AD
+a182;27AF
+a183;27B2
+a184;27B3
+a185;27B5
+a186;27B8
+a187;27BA
+a188;27BB
+a189;27BC
+a18;2712
+a190;27BD
+a191;27BE
+a192;279A
+a193;27AA
+a194;27B6
+a195;27B9
+a196;2798
+a197;27B4
+a198;27B7
+a199;27AC
+a19;2713
+a1;2701
+a200;27AE
+a201;27B1
+a202;2703
+a203;2750
+a204;2752
+a205;276E
+a206;2770
+a20;2714
+a21;2715
+a22;2716
+a23;2717
+a24;2718
+a25;2719
+a26;271A
+a27;271B
+a28;271C
+a29;2722
+a2;2702
+a30;2723
+a31;2724
+a32;2725
+a33;2726
+a34;2727
+a35;2605
+a36;2729
+a37;272A
+a38;272B
+a39;272C
+a3;2704
+a40;272D
+a41;272E
+a42;272F
+a43;2730
+a44;2731
+a45;2732
+a46;2733
+a47;2734
+a48;2735
+a49;2736
+a4;260E
+a50;2737
+a51;2738
+a52;2739
+a53;273A
+a54;273B
+a55;273C
+a56;273D
+a57;273E
+a58;273F
+a59;2740
+a5;2706
+a60;2741
+a61;2742
+a62;2743
+a63;2744
+a64;2745
+a65;2746
+a66;2747
+a67;2748
+a68;2749
+a69;274A
+a6;271D
+a70;274B
+a71;25CF
+a72;274D
+a73;25A0
+a74;274F
+a75;2751
+a76;25B2
+a77;25BC
+a78;25C6
+a79;2756
+a7;271E
+a81;25D7
+a82;2758
+a83;2759
+a84;275A
+a85;276F
+a86;2771
+a87;2772
+a88;2773
+a89;2768
+a8;271F
+a90;2769
+a91;276C
+a92;276D
+a93;276A
+a94;276B
+a95;2774
+a96;2775
+a97;275B
+a98;275C
+a99;275D
+a9;2720
+# END

data/lib/fillform/appearance.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+module Fillform
+  # The appearance stream iText's TextField#getAppearance builds: background and border of the widget,
+  # then the text with iText's auto font size, baseline, comb cells, alignment and line spacing.
+  class Appearance
+    COMB = 1 << 24
+    MULTILINE = 1 << 12
+    MULTILINE_MAX_AUTO_SIZE = 12
+    MIN_AUTO_SIZE = 4
+
+    DEFAULT_APPEARANCE = /(\S*)\s+([\d.]+)\s+Tf/
+    ROTATIONS = { 90 => [0, 1, -1, 0, :height, 0], 180 => [-1, 0, 0, -1, :width, :height],
+                  270 => [0, -1, 1, 0, 0, :width] }.freeze
+
+    # The fonts are looked up with a block: font(resources, name).
+    def initialize(doc, field, form:, &fonts)
+      @doc = doc
+      @field = field
+      @form = form
+      @fonts = fonts
+    end
+
+    def fill(value, shown = value)
+      @field[:V] = PDF::Text.encode(value)
+      @field.widgets.each { |widget| widget[:AP] = { N: stream_for(widget, shown) } }
+    end
+
+    # A combo box shows the text of the option whose export value is the value.
+    def fill_choice(value)
+      option = Array(@doc.deref(@field[:Opt])).map { |item| @doc.deref(item) }.find do |item|
+        item.is_a?(Array) && PDF::Text.decode(@doc.deref(item.first).to_s) == value
+      end
+      fill(value, option ? PDF::Text.decode(@doc.deref(option.last).to_s) : value)
+    end
+
+    # A list box shows the options from the first selected one on, the selected ones highlighted.
+    def fill_list(values)
+      options = choice_options
+      selections = values.filter_map { |value| options.index { |export, _display| export == value } }
+      @field[:V] = values.map { |value| PDF::Text.encode(value) }
+      @field[:I] = selections
+      @field.widgets.each do |widget|
+        widget[:AP] = { N: list_stream_for(widget, options.map(&:last), selections) }
+      end
+    end
+
+    private
+
+    LIST_HIGHLIGHT = Color.new([10, 36, 106].map { |component| component / 255.0 })
+
+    # [export, display] of each option.
+    def choice_options
+      Array(@doc.deref(@field[:Opt])).map do |option|
+        option = @doc.deref(option)
+        texts = Array(option).map { |text| PDF::Text.decode(@doc.deref(text).to_s) }
+        [texts.first, texts.last]
+      end
+    end
+
+    def list_stream_for(widget, choices, selections)
+      configure(widget)
+      @border = Border.new(@widget, @width, @height)
+      content = @border.appearance.b
+      content << "/Tx BMC ".b << list_text(choices, selections) << "EMC ".b unless choices.empty?
+      form_xobject(content)
+    end
+
+    def merged(key) = @widget[key]
+
+    # iText reads the attributes of each widget merged with the ones of its field and the form.
+    def configure(widget)
+      @widget = MergedWidget.new(widget, @field)
+      default_appearance = (merged(:DA) || @form[:DA]).to_s.b
+      name, size = default_appearance.match(DEFAULT_APPEARANCE)&.captures
+      resources = merged(:DR) || @form[:DR]
+      @font = @fonts.call(resources, name.to_s.split("/").last)
+      @font_size = size.to_f
+      @color = default_appearance.sub(DEFAULT_APPEARANCE, "").strip
+      @width, @height = box(widget.rect)
+      @width, @height = @height, @width if [90, 270].include?(rotation)
+    end
+
+    # The rotation of the widget's appearance characteristics, in multiples of 90 degrees.
+    def rotation
+      characteristics = @widget[:MK]
+      degrees = characteristics.is_a?(Hash) ? @doc.deref(characteristics[:R]).to_i : 0
+      (degrees % 90).zero? ? degrees % 360 : 0
+    end
+
+    def form_xobject(content)
+      matrix = ROTATIONS.fetch(rotation, [1, 0, 0, 1, 0, 0]).map do |value|
+        { width: @width, height: @height }.fetch(value, value)
+      end
+      @doc.add(PDF::Stream.compressed({ Type: :XObject, Subtype: :Form,
+                                        BBox: [0, 0, @width, @height].map { |number| n(number).to_f },
+                                        Matrix: matrix.map { |number| number.is_a?(Float) ? n(number).to_f : number },
+                                        Resources: { Font: { @font.key => @font.resource } } }, content))
+    end
+
+    # iText's TextField#getListAppearance
+    def list_text(choices, selections)
+      inset = @border.inner_width
+      size = @font_size.zero? ? MULTILINE_MAX_AUTO_SIZE : @font_size
+      leading = f(@font.top(size) - @font.bottom(size))
+      rows = visible_choices(choices.size, selections, f(inner_height / leading).to_i + 1)
+      clip = [inset, inset, f(@width - f(2 * inset)), f(@height - f(2 * inset))].map { |number| n(number) }.join(" ")
+      top = f(inset + inner_height)
+      "q #{clip} re W n #{LIST_HIGHLIGHT.fill} #{highlights(selections, rows, top, leading)}".b <<
+        list_rows(choices, selections, rows, size, top) << "Q ".b
+    end
+
+    def visible_choices(count, selections, fitting)
+      first = selections.first ? selections.first.clamp(0, count) : 0
+      return (first...(first + fitting)) if first + fitting <= count
+
+      ([0, count - fitting].max...count)
+    end
+
+    # iText also highlights a selection just below the last row it shows.
+    def highlights(selections, rows, top, leading)
+      inset = @border.inner_width
+      selections.grep(rows.begin..rows.end).map do |index|
+        "#{n(inset)} #{n(f(top - f(f(index - rows.begin + 1) * leading)))} " \
+          "#{n(f(@width - f(2 * inset)))} #{n(leading)} re f "
+      end.join
+    end
+
+    def list_rows(choices, selections, rows, size, top)
+      x = f(@border.inner_width * 2)
+      leading = f(@font.top(size) - @font.bottom(size))
+      baseline = f(top - @font.top(size))
+      rows.map do |index|
+        color = selections.include?(index) ? "1 g" : @color
+        chars = LineBreaker.rstrip(choices[index].gsub(/\r\n?|\n/, " ").chars)
+        y = shown_y(baseline)
+        baseline = f(baseline - leading)
+        "#{color} ".b << text_object(size, [[x, y, chars]])
+      end.join.b
+    end
+
+    def stream_for(widget, value)
+      configure(widget)
+      @border = Border.new(@widget, @width, @height, comb_cells: comb? ? max_length : 0)
+      form_xobject("#{@border.appearance}/Tx BMC ".b << variable_text(value) << "EMC ".b)
+    end
+
+    # iText computes the box in single precision.
+    def box(rect)
+      llx, lly, urx, ury = rect.pack("e4").unpack("e4")
+      [urx - llx, ury - lly].pack("e2").unpack("e2")
+    end
+
+    def variable_text(value)
+      return "".b if value.empty?
+
+      clip = [offset, offset, f(@width - f(2 * offset)), f(@height - f(2 * offset))].map { |number| n(number) }
+      "q #{clip.join(" ")} re W n #{@color} ".b << text(value) << "Q ".b
+    end
+
+    # iText's offX: the clipping inset
+    def offset = [@border.inner_width, padding].min
+
+    # iText's offsetX: the text inset
+    def padding = [@border.inner_width, 1].max
+
+    # iText's h: the height inside the border
+    def inner_height
+      height = f(@height - f(@border.width * 2))
+      @border.inner_width == @border.width ? height : f(height - f(@border.width * 2))
+    end
+
+    def text(value)
+      return multiline_text(value) if multiline?
+
+      chars = value.gsub(/\r\n?|\n/, " ").chars
+      size = @font_size.zero? ? auto_size(chars) : f(@font_size)
+      baseline = single_line_baseline(size)
+      comb? ? comb_text(chars, size, baseline) : single_line_text(chars, size, baseline)
+    end
+
+    # iText's ColumnText#showTextAligned: a column of 20000 points from the anchor of the alignment.
+    def single_line_text(chars, size, baseline)
+      anchor = case alignment
+               when :center then f(@width / 2)
+               when :right then f(@width - f(2 * padding))
+               else f(2 * padding)
+               end
+      left, right = case alignment
+                    when :center then [f(anchor - 20_000), f(anchor + 20_000)]
+                    when :right then [f(anchor - 20_000), anchor]
+                    else [anchor, f(anchor + 20_000)]
+                    end
+      line = LineBreaker.new(chars, f(right - left)) { |char| @font.char_width(char, size) }.lines.first
+      text_object(size, [[aligned_x(left, line.width_left), shown_y(baseline), line.chars]])
+    end
+
+    # PdfLine#indentLeft: the width left on the line moves it right, or half of it to the center.
+    def aligned_x(left, width_left)
+      case alignment
+      when :center then f(left + f(width_left / 2))
+      when :right then f(left + width_left)
+      else left
+      end
+    end
+
+    # ColumnText places the first line one leading (2 points) below the top of its column.
+    def shown_y(baseline) = f(f(baseline + 2) - 2)
+
+    def comb_text(chars, size, baseline)
+      step = f(@width / max_length)
+      start = f(f(step / 2) + f(comb_position(chars.size) * step))
+      glyphs = chars.map do |char|
+        x = f(start - f(@font.char_width(char, size) / 2))
+        start = f(start + step)
+        [x, baseline, [char]]
+      end
+      text_object(size, glyphs)
+    end
+
+    def comb_position(shown)
+      free = max_length - [max_length, shown].min
+      case alignment
+      when :center then free / 2
+      when :right then free
+      else 0
+      end
+    end
+
+    # iText's ColumnText in a column from 2 * offsetX to the width less 2 * offsetX, whose top is one
+    # leading above the first baseline.
+    def multiline_text(value)
+      paragraphs = value.split(/\r\n|\r|\n/, -1).map(&:chars)
+      size = @font_size.zero? ? multiline_auto_size(paragraphs) : f(@font_size)
+      leading = f(size * @font.line_factor)
+      left = f(2 * padding)
+      width = f(f(@width - f(2 * padding)) - left)
+      y = f(f(f(padding + inner_height) - @font.top(size)) + leading)
+      glyphs = lines(paragraphs, size, width).map do |line|
+        y = f(y - leading)
+        [aligned_x(left, line.width_left), y, line.chars]
+      end
+      text_object(size, glyphs)
+    end
+
+    def lines(paragraphs, size, width)
+      paragraphs.flat_map do |chars|
+        LineBreaker.new(chars, width) { |char| @font.char_width(char, size) }.lines
+      end
+    end
+
+    def text_object(size, glyphs)
+      shown = glyphs.map { |x, y, chars| "1 0 0 1 #{n(x)} #{n(y)} Tm ".b << literal(chars) << " Tj".b }
+      "BT #{PDF::Serializer.name(@font.key)} #{n(size)} Tf ".b << shown.join(" ").b << " ET ".b
+    end
+
+    # ColumnText#getWidth measures the text at size 1 in a 20000 point column: a text of whitespace
+    # only is an empty line, measures 20000 and gets the smallest size.
+    def auto_size(chars)
+      max_size = f(inner_height / @font.auto_size_factor)
+      line = LineBreaker.new(chars, 20_000) { |char| @font.char_width(char, 1) }.lines.first
+      text_width = f(20_000 - line.width_left)
+      return [max_size, MIN_AUTO_SIZE].max if text_width.zero?
+
+      [max_size, f(f(@width - f(4 * padding)) / text_width)].min.clamp(MIN_AUTO_SIZE..)
+    end
+
+    # iText shrinks the text from at most 12 points in tenths of the range, until ColumnText fits it in
+    # a column of the field's height.
+    def multiline_auto_size(paragraphs)
+      size = f(inner_height / @font.line_factor)
+      return MIN_AUTO_SIZE if size <= MIN_AUTO_SIZE
+
+      size = MULTILINE_MAX_AUTO_SIZE if size > MULTILINE_MAX_AUTO_SIZE
+      step = [f(f(size - MIN_AUTO_SIZE) / 10), f(0.2)].max
+      width = f(@width - f(4 * padding))
+      size = f(size - step) while size > MIN_AUTO_SIZE && !fits?(paragraphs, size, width)
+      [size, MIN_AUTO_SIZE].max
+    end
+
+    def fits?(paragraphs, size, width)
+      leading = f(@font.line_factor * size)
+      y = 0.0
+      lines(paragraphs, size, width).all? do
+        next false if f(y - leading) < -inner_height
+
+        y = f(y - leading)
+      end
+    end
+
+    def single_line_baseline(size)
+      ascent = @font.ascent(size)
+      descent = @font.descent(size)
+      baseline = f(offset + f(f(f(@height - f(2 * offset)) - ascent) / 2))
+      baseline = offset if baseline < offset
+      return baseline unless f(baseline - offset) < -descent
+
+      [f(-descent + offset), [baseline, f(f(@height - offset) - ascent)].max].min # rubocop:disable Style/ComparableClamp
+    end
+
+    def alignment = { 1 => :center, 2 => :right }.fetch(merged(:Q).to_i, :left)
+
+    def max_length = merged(:MaxLen).to_i
+
+    def comb? = merged(:Ff).to_i.anybits?(COMB) && max_length.positive?
+
+    def multiline? = merged(:Ff).to_i.anybits?(MULTILINE)
+
+    def literal(chars) = "(#{@font.encode_all(chars).pack("C*").gsub(/[()\\]/n) { |c| "\\#{c}" }})".b
+
+    def n(number) = Fillform.number(number)
+
+    def f(value) = Float32.f(value)
+  end
+end

data/lib/fillform/border.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Fillform
+  # Background and border of a widget, read and drawn like iText's BaseField#getBorderAppearance.
+  class Border
+    STYLES = { D: :dashed, B: :beveled, I: :inset, U: :underline }.freeze
+
+    attr_reader :width, :style
+
+    def initialize(widget, box_width, box_height, comb_cells: 0)
+      @box_width = box_width
+      @box_height = box_height
+      @comb_cells = comb_cells
+      characteristics = widget.resolve(widget[:MK])
+      characteristics = {} unless characteristics.is_a?(Hash)
+      @color = Color.from(characteristics[:BC])
+      @background = Color.from(characteristics[:BG])
+      @width = @color ? 1 : 0
+      @style = :solid
+      read_style(widget)
+    end
+
+    # The width the text keeps from the box: beveled and inset borders draw a second frame.
+    def inner_width = %i[beveled inset].include?(style) ? width * 2 : width
+
+    def appearance
+      operations = []
+      operations << "#{@background.fill} 0 0 #{n(@box_width)} #{n(@box_height)} re f" if @background
+      operations.concat(border)
+      operations.empty? ? "" : "q #{operations.join(" ")} Q "
+    end
+
+    private
+
+    # iText reads the legacy /Border array only when there is no border style dictionary.
+    def read_style(widget)
+      if (style = widget.resolve(widget[:BS])).is_a?(Hash)
+        @width = style[:W] if style.key?(:W)
+        @style = STYLES.fetch(style[:S], :solid)
+      elsif widget.key?(:Border) && (border = widget.resolve(widget[:Border])).is_a?(Array) && border.length >= 3
+        @width = border[2]
+        @style = :dashed if border.length >= 4
+      end
+    end
+
+    def border
+      case style
+      when :underline then stroked? ? [stroke_setup, underline] : []
+      when :beveled then frame + ["1 g", top_frame, (@background || Color.white).darker.fill, bottom_frame]
+      when :inset then frame + ["0.5 g", top_frame, "0.75 g", bottom_frame]
+      else frame(dashed: style == :dashed) + comb_dividers
+      end
+    end
+
+    def comb_dividers
+      return [] unless stroked? && @comb_cells > 1
+
+      step = @box_width / @comb_cells
+      bottom = n(width / 2.0)
+      top = n(@box_height - (width / 2.0))
+      lines = (1...@comb_cells).map { |cell| "#{n(step * cell)} #{bottom} m #{n(step * cell)} #{top} l" }
+      ["#{lines.join(" ")} S"]
+    end
+
+    def stroked? = width.positive? && @color
+
+    def underline = "0 #{n(width / 2.0)} m #{n(@box_width)} #{n(width / 2.0)} l S"
+
+    def stroke_setup = "#{@color.stroke} #{n(width)} w"
+
+    def frame(dashed: false)
+      return [] unless stroked?
+
+      inset = width / 2.0
+      ["#{"[3] 0 d " if dashed}#{stroke_setup}",
+       "#{n(inset)} #{n(inset)} #{n(@box_width - width)} #{n(@box_height - width)} re S"]
+    end
+
+    def top_frame
+      path([[width, width], [width, @box_height - width], [@box_width - width, @box_height - width],
+            [@box_width - (2 * width), @box_height - (2 * width)], [2 * width, @box_height - (2 * width)],
+            [2 * width, 2 * width], [width, width]])
+    end
+
+    def bottom_frame
+      path([[width, width], [@box_width - width, width], [@box_width - width, @box_height - width],
+            [@box_width - (2 * width), @box_height - (2 * width)], [@box_width - (2 * width), 2 * width],
+            [2 * width, 2 * width], [width, width]])
+    end
+
+    def path(points)
+      (x, y), *rest = points
+      "#{n(x)} #{n(y)} m #{rest.map { |px, py| "#{n(px)} #{n(py)} l" }.join(" ")} f"
+    end
+
+    def n(number) = Fillform.number(number)
+  end
+
+  # A color of the widget's appearance characteristics, rounded like a java.awt.Color.
+  class Color
+    def self.from(components)
+      components = Array(components).map(&:to_f)
+      new(components) unless components.empty?
+    end
+
+    def self.white = new([1, 1, 1])
+
+    def initialize(components)
+      @components = components.size == 3 ? components.map { |c| (c * 255).round / 255.0 } : components
+    end
+
+    def fill = "#{values} #{operator}"
+
+    def stroke = "#{values} #{operator.upcase}"
+
+    # java.awt.Color#darker, always in RGB
+    def darker = Color.new(rgb.map { |c| ((c * 255).round * 0.7).floor / 255.0 })
+
+    private
+
+    def rgb
+      case @components.size
+      when 1 then @components * 3
+      when 4
+        cyan, magenta, yellow, black = @components
+        [cyan, magenta, yellow].map { |c| (1 - c - black).clamp(0.0, 1.0) }
+      else @components
+      end
+    end
+
+    def values = @components.map { |c| Fillform.number(c) }.join(" ")
+
+    def operator = { 1 => "g", 3 => "rg", 4 => "k" }.fetch(@components.size)
+  end
+end