hexapdf 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77d9895ece62ee8b8df5afb5a44035868c6b33eb7b43a7cb5b85bd730bee56bc
-  data.tar.gz: 16b61502ef5c35df588c6a2fd53e1099b80f584276c07ec7a3c23343705ccb42
+  metadata.gz: 0cea16b918ff9aa6e7b32759295ef4ab38c899bcbd227d76ad42e0c971360239
+  data.tar.gz: 932c5edf01114a59d0a64776f304e29f3c8865a2c2c52c340064180464aabad7
 SHA512:
-  metadata.gz: 490fca7cfa535ebfab2af613dacf3ff9e9a6b0b2b76c865ceeb98a45d1cc7b668772dbd3a46ea00a5b82eb1374f36cb42b604754bbb1353e103cde726bc7e886
-  data.tar.gz: 1f85edaa9b2214218bb586d8c5409c9f741893fa0effdb60c64d294be231893ed96f1efa9db286d9a98f094caeb3fb272d318782dc7977adb8b252425d72cfb4
+  metadata.gz: 5883c5788487830b0403459b38b4ed1761c1015688977e9823f3c572f1ad645b06eb0578b185ce26f7f02c560050dd8ec7c09e8524b59cd35df4fd6abd1fb4aa
+  data.tar.gz: cdda51a089c86f27319fe424c9a74dc599ed60860338ef49958cd6a820141fa87a0624f2c657565e3f1b4a2392300807b89886178da6af62d22fa03fb543e372

data/CHANGELOG.md

@@ -1,3 +1,54 @@
+## 0.14.0 - 2020-12-30
+
+### Added
+
+* Support for creating AcroForm multiline text fields and their appearances
+* Support for creating AcroForm comb text fields and their appearances
+* Support for creating AcroForm password fields and their appearances
+* Support for creating AcroForm file select fields and their appearances
+* Support for creating AcroForm list box appearances
+* [HexaPDF::Type::AcroForm::ChoiceField#list_box_top_index] and its setter
+  method
+* [HexaPDF::Type::AcroForm::ChoiceField#update_widgets] to create appearances if
+  they don't exist
+* Methods for caching data to [HexaPDF::Object]
+* Support for splitting by page size to CLI command `hexapdf split`
+
+### Changed
+
+* [HexaPDF::Utils::ObjectHash#oids] to be public instead of private
+* Cross-reference table parsing to handle invalidly numbered main sections
+* [HexaPDF::Document#cache] and [HexaPDF::Object#cache] to allow updating
+  values for existing keys
+* Appearance creation methods of AcroForm objects to allow forcing the creation
+  of new appearances
+* [HexaPDF::Type::AcroForm::AppearanceGenerator#create_text_appearances] to
+  re-use existing form objects
+* AcroForm field creation methods to allow specifying often used field
+  properties
+
+### Fixed
+
+* Missing usage of `:sort` flag for AcroForm choice fields
+* Setting the `/I` field for AcroForm list boxes with multiple selection
+* [HexaPDF::Layout::TextLayouter::SimpleLineWrapping] to remove glue items
+  (whitespace) before a hard line break
+* Infinite loop when reconstructing the cross-reference table
+* [HexaPDF::Type::AcroForm::ChoiceField] to support export values for option
+  items
+* AcroForm text field appearance creation to only create a new appearance if the
+  field's value has changed
+* AcroForm choice field appearance creation to only create a new appearance if
+  the involved dictionary fields' values have changed
+* [HexaPDF::Type::AcroForm::ChoiceField#list_box_top_index=] to raise an error
+  if no option items are set
+* [HexaPDF::PDFArray#to_ary] to return an array with preprocessed values
+* [HexaPDF::Type::Form#contents=] to clear cached values to avoid returning e.g.
+  an invalid canvas object later
+* [HexaPDF::Type::AcroForm::ButtonField#update_widgets] to create appearances if
+  they don't exist
+
+
 ## 0.13.0 - 2020-11-15
 
 ### Added

data/examples/019-acro_form.rb

@@ -42,10 +42,47 @@ rb = form.create_radio_button("Radio")
 end
 rb.field_value = :button0
 
-canvas.text("Text field", at: [50, 450])
-tx = form.create_text_field("Single Line")
-widget = tx.create_widget(page, Rect: [200, 445, 500, 465])
-tx.set_default_appearance_string(font_size: 16)
+canvas.text("Text fields", at: [50, 450])
+
+canvas.text("Single line", at: [70, 420])
+tx = form.create_text_field("Single Line", font_size: 16)
+widget = tx.create_widget(page, Rect: [200, 415, 500, 435])
 tx.field_value = "A sample test string!"
 
+canvas.text("Multiline", at: [70, 390])
+tx = form.create_multiline_text_field("Multiline", font_size: 0, align: :right)
+widget = tx.create_widget(page, Rect: [200, 325, 500, 405])
+widget.border_style(color: 0, width: 1)
+tx.field_value = "A sample test string! " * 30 + "\nNew line\n\nAnother line"
+
+canvas.text("Password", at: [70, 300])
+tx = form.create_password_field("Password", font_size: 16)
+widget = tx.create_widget(page, Rect: [200, 295, 500, 315])
+
+canvas.text("File select", at: [70, 270])
+tx = form.create_file_select_field("File Select", font_size: 16)
+widget = tx.create_widget(page, Rect: [200, 265, 500, 285])
+tx.field_value = "path/to/file.pdf"
+
+canvas.text("Comb", at: [70, 240])
+tx = form.create_comb_text_field("Comb field", max_chars: 10, font_size: 16, align: :center)
+widget = tx.create_widget(page, Rect: [200, 220, 500, 255])
+widget.border_style(color: [30, 128, 0], width: 1)
+tx.field_value = 'Hello'
+
+canvas.text("Combo Box", at: [50, 170])
+cb = form.create_combo_box("Combo Box", font_size: 12, editable: true,
+                           option_items: ['Value 1', 'Another value', 'Choose me!'])
+widget = cb.create_widget(page, Rect: [200, 150, 500, 185])
+widget.border_style(width: 1)
+cb.field_value = 'Another value'
+
+canvas.text("List Box", at: [50, 120])
+lb = form.create_list_box("List Box", font_size: 15, align: :center, multi_select: true,
+                         option_items: 1.upto(7).map {|i| "Value #{i}" })
+widget = lb.create_widget(page, Rect: [200, 50, 500, 135])
+widget.border_style(width: 1)
+lb.list_box_top_index = 1
+lb.field_value = ['Value 6', 'Value 2']
+
 doc.write('acro_form.pdf', optimize: true)

data/lib/hexapdf/cli/split.rb

@@ -44,16 +44,28 @@ module HexaPDF
 
       def initialize #:nodoc:
         super('split', takes_commands: false)
-        short_desc("Split a PDF file into individual pages")
+        short_desc("Split a PDF file")
         long_desc(<<~EOF)
-          If no OUTPUT_SPEC is specified, the pages are named <PDF>_0001.pdf, <PDF>_0002.pdf, ...
-          and so on. To specify a custom name, provide the OUTPUT_SPEC argument. It can contain a
-          printf-style format definition like '%04d' to specify the place where the page number
-          should be inserted.
+          The default strategy is to split a PDF into individual pages, i.e. splitting is done by
+          page number. It is also possible to split by page size where pages with the same page size
+          get put into the same output PDF.
+
+          If no OUTPUT_SPEC is specified, the resulting PDF files are named <PDF>_0001.pdf,
+          <PDF>_0002.pdf, ... when splitting by page number and <PDF>_A4.pdf, <PDF>_Letter.pdf, ...
+          when splitting by page size.
+
+          To specify a custom name, provide the OUTPUT_SPEC argument. It can contain a printf-style
+          format definition like '%04d' to specify the place where the page number should be
+          inserted. In case of splitting by page size, the place of the format defintion is replaced
+          with the name of the page size, e.g. A4 or Letter.
 
           The optimization and encryption options are applied to each created output file.
         EOF
 
+        options.on("--strategy STRATEGY", "-s", [:page_number, :page_size], "Defines how the PDF " \
+                   "file should be split: page_number or page_size (default: page_number)") do |s|
+          @strategy = s
+        end
         options.on("--password PASSWORD", "-p", String,
                    "The password for decryption. Use - for reading from standard input.") do |pwd|
           @password = (pwd == '-' ? read_password : pwd)
@@ -62,23 +74,71 @@ module HexaPDF
         define_encryption_options
 
         @password = nil
+        @strategy = :page_number
       end
 
       def execute(pdf, output_spec = pdf.sub(/\.pdf$/i, '_%04d.pdf')) #:nodoc:
-        output_spec = output_spec.sub('%', '%<page>')
         with_document(pdf, password: @password) do |doc|
-          doc.pages.each_with_index do |page, index|
-            output_file = sprintf(output_spec, page: index + 1)
-            maybe_raise_on_existing_file(output_file)
-            out = HexaPDF::Document.new
-            out.pages.add(out.import(page))
-            apply_encryption_options(out)
-            apply_optimization_options(out)
-            write_document(out, output_file)
+          if @strategy == :page_number
+            split_by_page_number(doc, output_spec)
+          else
+            split_by_page_size(doc, output_spec)
           end
         end
       end
 
+      private
+
+      # Splits the document into individual pages.
+      def split_by_page_number(doc, output_spec)
+        doc.pages.each_with_index do |page, index|
+          output_file = sprintf(output_spec, index + 1)
+          maybe_raise_on_existing_file(output_file)
+          out = HexaPDF::Document.new
+          out.pages.add(out.import(page))
+          apply_encryption_options(out)
+          apply_optimization_options(out)
+          write_document(out, output_file)
+        end
+      end
+
+      # Splits the document into files based on the page sizes.
+      def split_by_page_size(doc, output_spec)
+        output_spec = output_spec.sub(/%.*?[a-zA-Z]/, '%s')
+        out_files = Hash.new do |hash, key|
+          output_file = sprintf(output_spec, key)
+          maybe_raise_on_existing_file(output_file)
+          out = HexaPDF::Document.new
+          out.config['output_file'] = output_file
+          hash[key] = out
+        end
+
+        doc.pages.each do |page|
+          out = out_files[page_size_name(page.box(:media).value)]
+          out.pages.add(out.import(page))
+        end
+
+        out_files.each_value do |out|
+          apply_encryption_options(out)
+          apply_optimization_options(out)
+          write_document(out, out.config['output_file'])
+        end
+      end
+
+      # Tries to retrieve a page size name based on the media box. If this is not possible, the
+      # returned page size name consists of width x height.
+      def page_size_name(media_box)
+        @page_name_cache ||= {}
+        return @page_name_cache[media_box] if @page_name_cache.key?(media_box)
+
+        paper_size = HexaPDF::Type::Page::PAPER_SIZE.find do |_name, box|
+          box.each_with_index.all? {|entry, index| (entry - media_box[index]).abs < 5 }
+        end
+
+        @page_name_cache[media_box] =
+          paper_size ? paper_size[0] : "%.0fx%.0f" % media_box.values_at(2, 3)
+      end
+
     end
 
   end

data/lib/hexapdf/document.rb

@@ -469,15 +469,21 @@ module HexaPDF
       @listeners[name]&.each {|obj| obj.call(*args) }
     end
 
-    # Caches the value or the return value of the given block using the given Object::PDFData and
-    # key arguments as composite hash key. If a cached value already exists, it is just returned.
+    UNSET = ::Object.new # :nordoc:
+
+    # Caches and returns the given +value+ or the value of the given block using the given
+    # +pdf_data+ and +key+ arguments as composite cache key. If a cached value already exists and
+    # +update+ is +false+, the cached value is just returned.
+    #
+    # Set +update+ to +true+ to force an update of the cached value.
     #
     # This facility can be used to cache expensive operations in PDF objects that are easy to
     # compute again.
     #
     # Use #clear_cache to clear the cache if necessary.
-    def cache(pdf_data, key, value = nil)
-      @cache[pdf_data][key] ||= value || yield
+    def cache(pdf_data, key, value = UNSET, update: false)
+      return @cache[pdf_data][key] if cached?(pdf_data, key) && !update
+      @cache[pdf_data][key] = (value == UNSET ? yield : value)
     end
 
     # Returns +true+ if there is a value cached for the composite key consisting of the given

data/lib/hexapdf/layout/text_layouter.rb

@@ -388,7 +388,7 @@ module HexaPDF
               end
             when :penalty
               if item.penalty <= -Penalty::INFINITY
-                add_box_item(item.item) if item.item
+                add_box_item(item.item) if item.width > 0
                 break unless yield(create_unjustified_line, item)
                 reset_after_line_break(index + 1)
               elsif item.penalty >= Penalty::INFINITY
@@ -458,7 +458,7 @@ module HexaPDF
               end
             when :penalty
               if item.penalty <= -Penalty::INFINITY
-                add_box_item(item.item) if item.item
+                add_box_item(item.item) if item.width > 0
                 break unless (action = yield(create_unjustified_line, item))
                 reset_after_line_break_variable_width(index + 1, true, action)
               elsif item.penalty >= Penalty::INFINITY

data/lib/hexapdf/object.rb

@@ -284,6 +284,28 @@ module HexaPDF
       obj
     end
 
+    # Caches and returns the given +value+ or the value of the block under the given cache key. If
+    # there is already a cached value for the key and +update+ is +false+, it is just returned.
+    #
+    # Set +update+ to +true+ to force an update of the cached value.
+    #
+    # This uses Document#cache internally.
+    def cache(key, value = Document::UNSET, update: false, &block)
+      document.cache(@data, key, value, update: update, &block)
+    end
+
+    # Returns +true+ if there is a cached value for the given key.
+    #
+    # This uses Document#cached? internally.
+    def cached?(key)
+      document.cached?(@data, key)
+    end
+
+    # Clears the cache for this object.
+    def clear_cache
+      document.clear_cache(@data)
+    end
+
     # Compares this object to another object.
     #
     # If the other object does not respond to +oid+ or +gen+, +nil+ is returned. Otherwise objects

data/lib/hexapdf/parser.rb

@@ -267,6 +267,27 @@ module HexaPDF
         raise_malformed("Trailer is #{trailer.class} instead of dictionary ", pos: @tokenizer.pos)
       end
 
+      unless trailer[:Prev] || xref.max_oid == 0 || xref.entry?(0)
+        first_entry = xref[xref.oids[0]]
+        test_entry = xref[xref.oids[-1]]
+        @tokenizer.pos = test_entry.pos + @header_offset
+        test_oid = @tokenizer.next_token
+        first_oid = first_entry.oid
+
+        force_failure = !first_entry.free? || first_entry.gen != 65535 ||
+          !test_oid.kind_of?(Integer) || xref.oids[-1] - test_oid != first_oid
+        maybe_raise("Main cross-reference section has invalid numbering",
+                    pos: offset + @header_offset, force: force_failure)
+
+        new_xref = XRefSection.new
+        xref.oids.each do |oid|
+          entry = xref[oid]
+          entry.oid -= first_oid
+          new_xref.send(:[]=, entry.oid, entry.gen, entry)
+        end
+        xref = new_xref
+      end
+
       [xref, trailer]
     end
 
@@ -359,8 +380,9 @@ module HexaPDF
       xref = XRefSection.new
       @tokenizer.pos = 0
       while true
+        @tokenizer.skip_whitespace
         pos = @tokenizer.pos
-        @tokenizer.scan_until(/(\n|\r\n?)+|\z/)
+        @tokenizer.scan_until(/(\n|\r\n?)+/)
         next_new_line_pos = @tokenizer.pos
         @tokenizer.pos = pos
 

data/lib/hexapdf/pdf_array.rb

@@ -181,9 +181,9 @@ module HexaPDF
       self
     end
 
-    # Returns a duplicate of the underlying array.
+    # Returns an array containing the preprocessed values (like in #[]).
     def to_ary
-      value.dup
+      each.to_a
     end
 
     private

data/lib/hexapdf/type/acro_form/appearance_generator.rb

@@ -37,6 +37,7 @@
 require 'hexapdf/error'
 require 'hexapdf/layout/style'
 require 'hexapdf/layout/text_fragment'
+require 'hexapdf/layout/text_layouter'
 
 module HexaPDF
   module Type
@@ -80,14 +81,8 @@ module HexaPDF
             else
               raise HexaPDF::Error, "Unsupported button field type"
             end
-          when :Tx
+          when :Tx, :Ch
             create_text_appearances
-          when :Ch
-            if @field.combo_box?
-              create_text_appearances
-            else
-              raise HexaPDF::Error, "List box not supported yet"
-            end
           else
             raise HexaPDF::Error, "Unsupported field type #{@field.field_type}"
           end
@@ -249,38 +244,35 @@ module HexaPDF
             rect.height = style.scaled_y_max - style.scaled_y_min + 2 * padding
           end
 
-          form = (@widget[:AP] ||= {})[:N] = @document.add({Type: :XObject, Subtype: :Form,
-                                                            BBox: [0, 0, rect.width, rect.height]})
+          form = (@widget[:AP] ||= {})[:N] ||= @document.add({Type: :XObject, Subtype: :Form})
+          form.value.replace({Type: :XObject, Subtype: :Form, BBox: [0, 0, rect.width, rect.height]})
+          form.contents = ''
           form[:Resources] = HexaPDF::Object.deep_copy(default_resources)
 
           canvas = form.canvas
           apply_background_and_border(border_style, canvas)
           style.font_size = calculate_font_size(font, font_size, rect, border_style)
+          style.clear_cache
 
           canvas.marked_content_sequence(:Tx) do
-            if (value = @field.field_value)
+            if @field.field_value || @field.concrete_field_type == :list_box
               canvas.save_graphics_state do
                 canvas.rectangle(padding, padding, rect.width - 2 * padding,
                                  rect.height - 2 * padding).clip_path.end_path
-                fragment = HexaPDF::Layout::TextFragment.create(value, style)
-                # Adobe seems to be left/right-aligning based on twice the border width and
-                # vertically centering based on the cap height, if enough space is available
-                x = case @field.text_alignment
-                    when :left then 2 * padding
-                    when :right then [rect.width - 2 * padding - fragment.width, 2 * padding].max
-                    when :center then [(rect.width - fragment.width) / 2.0, 2 * padding].max
-                    end
-                cap_height = font.wrapped_font.cap_height * font.scaling_factor / 1000.0 *
-                  style.font_size
-                y = padding + (rect.height - 2 * padding - cap_height) / 2.0
-                y = padding - style.scaled_font_descender if y < 0
-                fragment.draw(canvas, x, y)
+                if @field.concrete_field_type == :multiline_text_field
+                  draw_multiline_text(canvas, rect, style, padding)
+                elsif @field.concrete_field_type == :list_box
+                  draw_list_box(canvas, rect, style, padding)
+                else
+                  draw_single_line_text(canvas, rect, style, padding)
+                end
               end
             end
           end
         end
 
         alias create_combo_box_appearances create_text_appearances
+        alias create_list_box_appearances create_text_appearances
 
         private
 
@@ -341,6 +333,13 @@ module HexaPDF
                   canvas.circle(rect.width / 2.0, rect.height / 2.0, [width / 2.0, height / 2.0].min)
                 else
                   canvas.rectangle(offset, offset, width, height)
+                  if @field.concrete_field_type == :comb_text_field
+                    cell_width = rect.width.to_f / @field[:MaxLen]
+                    1.upto(@field[:MaxLen] - 1) do |i|
+                      canvas.line(i * cell_width, border_style.width,
+                                  i * cell_width, border_style.width + height)
+                    end
+                  end
                 end
               end
               canvas.stroke
@@ -385,14 +384,115 @@ module HexaPDF
           end
         end
 
+        # Draws a single line of text inside the widget's rectangle.
+        def draw_single_line_text(canvas, rect, style, padding)
+          value = @field.field_value
+          fragment = HexaPDF::Layout::TextFragment.create(value, style)
+
+          if @field.concrete_field_type == :comb_text_field
+            unless @field.key?(:MaxLen)
+              raise HexaPDF::Error, "Missing or invalid dictionary field /MaxLen for comb text field"
+            end
+            new_items = []
+            cell_width = rect.width.to_f / @field[:MaxLen]
+            scaled_cell_width = cell_width / style.scaled_font_size.to_f
+            fragment.items.each_cons(2) do |a, b|
+              new_items << a << -(scaled_cell_width - a.width / 2.0 - b.width / 2.0)
+            end
+            new_items << fragment.items.last
+            fragment.items.replace(new_items)
+            fragment.clear_cache
+            # Adobe always seems to add 1 to the first offset...
+            x_offset = 1 + (cell_width - style.scaled_item_width(fragment.items[0])) / 2.0
+            x = case @field.text_alignment
+                when :left then x_offset
+                when :right then x_offset + cell_width * (@field[:MaxLen] - value.length)
+                when :center then x_offset + cell_width * ((@field[:MaxLen] - value.length) / 2)
+                end
+          else
+            # Adobe seems to be left/right-aligning based on twice the border width
+            x = case @field.text_alignment
+                when :left then 2 * padding
+                when :right then [rect.width - 2 * padding - fragment.width, 2 * padding].max
+                when :center then [(rect.width - fragment.width) / 2.0, 2 * padding].max
+                end
+          end
+
+          # Adobe seems to be vertically centering based on the cap height, if enough space is
+          # available
+          cap_height = style.font.wrapped_font.cap_height * style.font.scaling_factor / 1000.0 *
+            style.font_size
+          y = padding + (rect.height - 2 * padding - cap_height) / 2.0
+          y = padding - style.scaled_font_descender if y < 0
+          fragment.draw(canvas, x, y)
+        end
+
+        # Draws multiple lines  of text inside the widget's rectangle.
+        def draw_multiline_text(canvas, rect, style, padding)
+          items = [Layout::TextFragment.create(@field.field_value, style)]
+          layouter = Layout::TextLayouter.new(style)
+          layouter.style.align(@field.text_alignment).line_spacing(:proportional, 1.25)
+
+          result = nil
+          if style.font_size == 0 # need to auto-size text
+            style.font_size = 12 # Adobe seems to use this as starting point
+            style.clear_cache
+            loop do
+              result = layouter.fit(items, rect.width - 4 * padding, rect.height - 4 * padding)
+              break if result.status == :success || style.font_size <= 4 # don't make text too small
+              style.font_size -= 1
+              style.clear_cache
+            end
+          else
+            result = layouter.fit(items, rect.width - 4 * padding, 2**20)
+          end
+
+          unless result.lines.empty?
+            result.draw(canvas, 2 * padding, rect.height - 2 * padding - result.lines[0].height / 2.0)
+          end
+        end
+
+        # Draws the visible option items of the list box in the widget's rectangle.
+        def draw_list_box(canvas, rect, style, padding)
+          option_items = @field.option_items
+          top_index = @field.list_box_top_index
+          items = [Layout::TextFragment.create(option_items[top_index..-1].join("\n"), style)]
+
+          indices = @field[:I] || []
+          value_indices = [@field.field_value].flatten.compact.map {|val| option_items.index(val) }
+          indices = value_indices if indices != value_indices
+
+          layouter = Layout::TextLayouter.new(style)
+          layouter.style.align(@field.text_alignment).line_spacing(:proportional, 1.25)
+          result = layouter.fit(items, rect.width - 4 * padding, rect.height)
+
+          unless result.lines.empty?
+            top_gap = style.line_spacing.gap(result.lines[0], result.lines[0])
+            line_height = style.line_spacing.baseline_distance(result.lines[0], result.lines[0])
+            canvas.fill_color(153, 193, 218) # Adobe's color for selection highlighting
+            indices.map! {|i| rect.height - padding - (i - top_index + 1) * line_height }.each do |y|
+              next if y + line_height > rect.height || y + line_height < padding
+              canvas.rectangle(padding, y, rect.width - 2 * padding, line_height)
+            end
+            canvas.fill if canvas.graphics_object == :path
+            result.draw(canvas, 2 * padding, rect.height - padding - top_gap)
+          end
+        end
+
         # Calculates the font size for text fields based on the font and font size of the default
         # appearance string, the annotation rectangle and the border style.
         def calculate_font_size(font, font_size, rect, border_style)
           if font_size == 0
-            unit_font_size = (font.wrapped_font.bounding_box[3] - font.wrapped_font.bounding_box[1]) *
-              font.scaling_factor / 1000.0
-            # The constant factor was found empirically by checking what Adobe Reader etc. do
-            (rect.height - 2 * border_style.width) / unit_font_size * 0.83
+            if @field.concrete_field_type == :multiline_text_field
+              0 # Handled by multiline drawing code
+            elsif @field.concrete_field_type == :list_box
+              12 # Seems to be Adobe's default
+            else
+              unit_font_size = (font.wrapped_font.bounding_box[3] - font.wrapped_font.bounding_box[1]) *
+                font.scaling_factor / 1000.0
+              # The constant factor was found empirically by checking what Adobe Reader etc. do
+              (rect.height - 2 * border_style.width) / unit_font_size * 0.83
+            end
           else
             font_size
           end