hexapdf 1.1.1 → 1.3.0

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

@@ -174,11 +174,59 @@ module HexaPDF
 
         alias create_radio_button_appearances create_check_box_appearances
 
-        # Creates the appropriate appearances for push buttons.
+        # Creates the appropriate appearances for push button fields
         #
-        # This is currently a dummy implementation raising an error.
+        # The following describes how the appearance is built:
+        #
+        # * The widget's rectangle /Rect must be defined.
+        #
+        # * If the font size (used for the caption) is zero, a font size of
+        #   +acro_form.default_font_size+ is used.
+        #
+        # * The line width, style and color of the rectangle are taken from the widget's border
+        #   style. See HexaPDF::Type::Annotations::Widget#border_style.
+        #
+        # * The background color is determined by the widget's background color. See
+        #   HexaPDF::Type::Annotations::Widget#background_color.
         def create_push_button_appearances
-          raise HexaPDF::Error, "Push button appearance generation not yet supported"
+          default_resources = @document.acro_form(create: true).default_resources
+          border_style = @widget.border_style
+          padding = border_style.width
+          marker_style = @widget.marker_style
+          font = retrieve_font_information(marker_style.font_name, default_resources)
+
+          @widget[:AS] = :N
+          @widget.flag(:print)
+          @widget.unflag(:hidden)
+          rect = @widget[:Rect]
+
+          width, height, matrix = perform_rotation(rect.width, rect.height)
+
+          form = (@widget[:AP] ||= {})[:N] ||= @document.add({Type: :XObject, Subtype: :Form})
+          # Wrap existing object in Form class in case the PDF writer didn't include the /Subtype
+          # key or the type of the object is wrong; we can do this since we know this has to be a
+          # Form object
+          unless form.type == :XObject && form[:Subtype] == :Form
+            form = @document.wrap(form, type: :XObject, subtype: :Form)
+          end
+          form.value.replace({Type: :XObject, Subtype: :Form, BBox: [0, 0, width, height],
+                              Matrix: matrix, Resources: HexaPDF::Object.deep_copy(default_resources)})
+          form.contents = ''
+
+          canvas = form.canvas
+          apply_background_and_border(border_style, canvas)
+
+          style = HexaPDF::Layout::Style.new(font: font, font_size: marker_style.size,
+                                             fill_color: marker_style.color)
+          if (text = marker_style.style) && text.kind_of?(String)
+            items = @document.layout.text_fragments(marker_style.style, style: style)
+            layouter = Layout::TextLayouter.new(style)
+            layouter.style.text_align(:center).text_valign(:center).line_spacing(:proportional, 1.25)
+            result = layouter.fit(items, width - 2 * padding, height - 2 * padding)
+            unless result.lines.empty?
+              result.draw(canvas, padding, height - padding)
+            end
+          end
         end
 
         # Creates the appropriate appearances for text fields, combo box fields and list box fields.
@@ -207,7 +255,8 @@ module HexaPDF
         # Note: Rich text fields are currently not supported!
         def create_text_appearances
           default_resources = @document.acro_form.default_resources
-          font, font_size, font_color = retrieve_font_information(default_resources)
+          font_name, font_size, font_color = @field.parse_default_appearance_string(@widget)
+          font = retrieve_font_information(font_name, default_resources)
           style = HexaPDF::Layout::Style.new(font: font, font_size: font_size, fill_color: font_color)
           border_style = @widget.border_style
           padding = [1, border_style.width].max
@@ -475,9 +524,9 @@ module HexaPDF
           end
         end
 
-        # Returns the font wrapper and font size to be used for a variable text field.
-        def retrieve_font_information(resources)
-          font_name, font_size, font_color = @field.parse_default_appearance_string(@widget)
+        # Returns the font wrapper, font size and font color to be used for variable text fields and
+        # push button captions.
+        def retrieve_font_information(font_name, resources)
           font_object = resources.font(font_name) rescue nil
           font = font_object&.font_wrapper
           unless font
@@ -493,7 +542,7 @@ module HexaPDF
               raise(HexaPDF::Error, "Font #{font_name} of the AcroForm's default resources not usable")
             end
           end
-          [font, font_size, font_color]
+          font
         end
 
         # Calculates the font size for single line text fields using auto-sizing, based on the font

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

@@ -392,6 +392,7 @@ module HexaPDF
               break # Each annotation dictionary may only appear on one page, see PDF2.0 12.5.2
             end
           end
+          document.revisions.current.update(self)
           widget
         end
 

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

@@ -568,12 +568,12 @@ module HexaPDF
           seen = {} # used for combining field
 
           validate_array = lambda do |parent, container|
-            container.reject! do |field|
+            container.map! do |field|
               if !field.kind_of?(HexaPDF::Object) || !field.kind_of?(HexaPDF::Dictionary) || field.null?
                 yield("Invalid object in AcroForm field hierarchy", true)
-                next true
+                next nil
               end
-              next false unless field.key?(:T) # Skip widgets
+              next field unless field.key?(:T) # Skip widgets
 
               field = Field.wrap(document, field)
               reject = false
@@ -597,14 +597,15 @@ module HexaPDF
                   widget[:Parent] = other_field
                   kids << widget
                 end
+                document.delete(field)
                 reject = true
               elsif !reject
                 seen[name] = field
               end
 
-              validate_array.call(field, field[:Kids]) if field.key?(:Kids)
-              reject
-            end
+              validate_array.call(field, field[:Kids]) if !field.null? && field.key?(:Kids)
+              reject ? nil : field
+            end.compact!
           end
           validate_array.call(nil, root_fields)
 

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

@@ -496,7 +496,7 @@ module HexaPDF
                    else
                      nil
                    end
-          result && (result == result.truncate ? result.to_i.to_s : result.to_s)
+          result && (result.finite? && result == result.truncate ? result.to_i.to_s : result.to_s)
         end
 
         AF_SIMPLE_CALCULATE_MAPPING = { #:nodoc:
@@ -613,7 +613,14 @@ module HexaPDF
 
         # Returns the numeric value of the string, interpreting comma as point.
         def af_make_number(value)
-          value.to_s.tr(',', '.').to_f
+          value = value.to_s
+          if value.match?(/(?:[+-])?Inf(?:inity)?/i)
+            value.start_with?('-') ? -Float::INFINITY : Float::INFINITY
+          elsif value.match?(/NaN/i)
+            Float::NAN
+          else
+            value.tr(',', '.').to_f
+          end
         end
 
         # Formats the numeric value according to the format string and separator style.

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

@@ -176,7 +176,7 @@ module HexaPDF
           end
           str = str.gsub(/[[:space:]]/, ' ') if str && concrete_field_type == :single_line_text_field
           if key?(:MaxLen) && str && str.length > self[:MaxLen]
-            raise HexaPDF::Error, "Value exceeds maximum allowed length of #{self[:MaxLen]}"
+            str = @document.config['acro_form.text_field.on_max_len_exceeded'].call(self, str)
           end
           self[:V] = str
           update_widgets
@@ -348,7 +348,14 @@ module HexaPDF
             return
           end
           if (max_len = self[:MaxLen]) && field_value && field_value.length > max_len
-            yield("Text contents of field '#{full_field_name}' is too long")
+            correctable = true
+            begin
+              str = @document.config['acro_form.text_field.on_max_len_exceeded'].call(self, field_value)
+            rescue HexaPDF::Error
+              correctable = false
+            end
+            yield("Text contents of field '#{full_field_name}' is too long", correctable)
+            self.field_value = str if correctable
           end
           if comb_text_field? && !max_len
             yield("Comb text field needs a value for /MaxLen")

data/lib/hexapdf/type/annotation.rb

@@ -113,6 +113,18 @@ module HexaPDF
 
       end
 
+      # Border effect dictionary used by square, circle and polygon annotation types.
+      #
+      # See: PDF2.0 s12.5.4
+      class BorderEffect < Dictionary
+
+        define_type :XXBorderEffect
+
+        define_field :S,    type: Symbol, default: :S, allowed_values: [:C, :S]
+        define_field :I,    type: Numeric, default: 0, allowed_values: [0, 1, 2]
+
+      end
+
       extend Utils::BitField
 
       define_type :Annot
@@ -133,7 +145,7 @@ module HexaPDF
       define_field :OC,           type: Dictionary, version: '1.5'
       define_field :AF,           type: PDFArray, version: '2.0'
       define_field :ca,           type: Numeric, default: 1.0, version: '2.0'
-      define_field :CA,           type: Numeric, default: 1.0, version: '2.0'
+      define_field :CA,           type: Numeric, default: 1.0, version: '1.4'
       define_field :BM,           type: Symbol, version: '2.0'
       define_field :Lang,         type: String, version: '2.0'
 
@@ -259,6 +271,64 @@ module HexaPDF
         xobject
       end
 
+      # Regenerates the appearance stream of the annotation.
+      #
+      # This uses the information stored in the annotation to regenerate the appearance.
+      #
+      # See: Annotations::AppearanceGenerator
+      def regenerate_appearance
+        appearance_generator_class = document.config.constantize('annotation.appearance_generator')
+        appearance_generator_class.new(self).create_appearance
+      end
+
+      # :call-seq:
+      #   annot.contents        => contents or +nil+
+      #   annot.contents(text)  => annot
+      #
+      # Returns the text of the annotation when no argument is given. Otherwise sets the text and
+      # returns self.
+      #
+      # The contents is used differently depending on the annotation type. It is either the text
+      # that should be displayed for the annotation or an alternate description of the annotation's
+      # contents.
+      #
+      # A value of +nil+ means deleting the existing contents entry.
+      def contents(text = :UNSET)
+        if text == :UNSET
+          self[:Contents]
+        else
+          self[:Contents] = text
+          self
+        end
+      end
+
+      # Describes the opacity values +fill_alpha+ and +stroke_alpha+ of an annotation.
+      #
+      # See Annotation#opacity
+      Opacity = Struct.new(:fill_alpha, :stroke_alpha)
+
+      # :call-seq:
+      #   annotation.opacity                                           => current_values
+      #   annotation.opacity(fill_alpha:)                              => annotation
+      #   annotation.opacity(stroke_alpha:)                            => annotation
+      #   annotation.opacity(fill_alpha:, stroke_alpha:)               => annotation
+      #
+      # Returns an Opacity instance representing the fill and stroke alpha values when no arguments
+      # are given. Otherwise sets the provided alpha values and returns self.
+      #
+      # The fill and stroke alpha values are used when regenerating the annotation's appearance
+      # stream and determine how opaque drawn elements will be. Note that the fill alpha value
+      # applies not just to fill values but to all non-stroking operations (e.g. images, ...).
+      def opacity(fill_alpha: nil, stroke_alpha: nil)
+        if !fill_alpha.nil? || !stroke_alpha.nil?
+          self[:CA] = stroke_alpha unless stroke_alpha.nil?
+          self[:ca] = fill_alpha unless fill_alpha.nil?
+          self
+        else
+          Opacity.new(key?(:ca) ? self[:ca] : self[:CA], self[:CA])
+        end
+      end
+
       private
 
       def perform_validation(&block) #:nodoc:

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

@@ -0,0 +1,348 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2025 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'hexapdf/error'
+
+module HexaPDF
+  module Type
+    module Annotations
+
+      # The AppearanceGenerator class provides methods for generating the appearance streams of
+      # annotations except those for widgets (see HexaPDF::Type::AcroForm::AppearanceGenerator for
+      # those).
+      #
+      # There is one private create_TYPE_appearance method for each annotation type. This allows
+      # subclassing the appearance generator and adjusting the appearances to one's needs.
+      #
+      # By default, an existing appearance is overwritten and the +:print+ flag is set as well as
+      # the +:hidden+ flag unset on the annotation so that the appearance will appear on print-outs.
+      #
+      # Also note that the annotation's /Rect entry is modified so that it contains the whole
+      # generated appearance.
+      #
+      # The visual appearances are chosen to be similar to those used by Adobe Acrobat and others.
+      # By subclassing and overriding the necessary methods it is possible to define custom
+      # appearances.
+      #
+      # The default annotation appearance generator for a document can be changed using the
+      # 'annotation.appearance_generator' configuration option.
+      #
+      # See: PDF2.0 s12.5
+      class AppearanceGenerator
+
+        # Creates a new instance for the given +annotation+.
+        def initialize(annotation)
+          @annot = annotation
+          @document = annotation.document
+        end
+
+        # Creates the appropriate appearance for the annotation provided on initialization.
+        def create_appearance
+          case @annot[:Subtype]
+          when :Line then create_line_appearance
+          when :Square then create_square_circle_appearance(:square)
+          when :Circle then create_square_circle_appearance(:circle)
+          else
+            raise HexaPDF::Error, "Appearance regeneration for #{@annot[:Subtype]} not yet supported"
+          end
+        end
+
+        private
+
+        # Creates the appropriate appearance for a line annotation.
+        #
+        # Nearly all the needed information can be taken from the annotation object itself. However,
+        # the PDF specification doesn't specify where to take the font related information (font,
+        # size, alignment...) from. Therefore this is currently hard-coded as left-aligned Helvetica
+        # in size 9.
+        #
+        # There are also some other decisions that are left to the implementation, like padding
+        # around the annotation or the size of the line ending shapes. Those are implemented to be
+        # similar to how viewers create the appearance.
+        #
+        # See: HexaPDF::Type::Annotations::Line
+        def create_line_appearance
+          # Prepare the annotation
+          form = (@annot[:AP] ||= {})[:N] ||=
+            @document.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, 0, 0]})
+          form.contents = ""
+          @annot.flag(:print)
+          @annot.unflag(:hidden)
+
+          # Get or calculate all needed values from the annotation
+          x0, y0, x1, y1 = @annot.line
+          style = @annot.border_style
+          line_ending_style = @annot.line_ending_style
+          opacity = @annot.opacity
+          ll = @annot.leader_line_length
+          lle = @annot.leader_line_extension_length
+          llo = @annot.leader_line_offset
+
+          angle = Math.atan2(y1 - y0, x1 - x0)
+          cos_angle = Math.cos(angle)
+          sin_angle = Math.sin(angle)
+          line_length = Math.sqrt((y1 - y0) ** 2 + (x1 - x0) ** 2)
+          ll_sign = (ll > 0 ? 1 : -1)
+          ll_y = ll_sign * (ll.abs + lle + llo)
+          line_y = (ll != 0 ? ll_sign * (llo + ll.abs) : 0)
+
+          captioned = @annot.captioned
+          contents = @annot.contents.to_s
+          if captioned && !contents.empty?
+            cap_position = @annot.caption_position
+            cap_style = HexaPDF::Layout::Style.new(font: 'Helvetica', font_size: 9,
+                                                   fill_color: style.color || 'black',
+                                                   line_spacing: 1.25)
+            cap_items = @document.layout.text_fragments(contents, style: cap_style)
+            layouter = Layout::TextLayouter.new(cap_style)
+            cap_result = layouter.fit(cap_items, 2**20, 2**20)
+            cap_width = cap_result.lines.max_by(&:width).width + 2 # for padding left/right
+            cap_offset = @annot.caption_offset
+
+            cap_x = (line_length - cap_width) / 2.0 + cap_offset[0]
+            # Note that the '+ 2' is just so that there is a small gap to the line
+            cap_y = line_y + cap_offset[1] +
+                    (cap_position == :inline ? cap_result.height / 2.0 : cap_result.height + 2)
+          end
+
+          # Calculate annotation rectangle and form bounding box. This considers the line's start
+          # and end points as well as the end points of the leader lines, the line ending style and
+          # the caption when calculating the bounding box.
+          #
+          # The result could still be improved by tailoring to the specific line ending style.
+          calculate_le_padding = lambda do |le_style|
+            case le_style
+            when :square, :circle, :diamond, :slash, :open_arrow, :closed_arrow
+              3 * style.width
+            when :ropen_arrow, :rclosed_arrow
+              10 * style.width
+            else
+              0
+            end
+          end
+          dstart = calculate_le_padding.call(line_ending_style.start_style)
+          dend = calculate_le_padding.call(line_ending_style.end_style)
+          if captioned
+            cap_ulx = x0 + cos_angle * cap_x - sin_angle * cap_y
+            cap_uly = y0 + sin_angle * cap_x + cos_angle * cap_y
+          end
+          min_x, max_x = [x0, x0 - sin_angle * ll_y, x0 - sin_angle * line_y - cos_angle * dstart,
+                          x1, x1 - sin_angle * ll_y, x1 - sin_angle * line_y + cos_angle * dend,
+                          *([cap_ulx,
+                             cap_ulx + cos_angle * cap_width,
+                             cap_ulx - sin_angle * cap_result.height,
+                             cap_ulx + cos_angle * cap_width - sin_angle * cap_result.height
+                            ] if captioned)
+                         ].minmax
+          min_y, max_y = [y0, y0 + cos_angle * ll_y,
+                          y0 + cos_angle * line_y - ([cos_angle, sin_angle].max) * dstart,
+                          y1, y1 + cos_angle * ll_y,
+                          y1 + cos_angle * line_y + ([cos_angle, sin_angle].max) * dend,
+                          *([cap_uly,
+                             cap_uly + sin_angle * cap_width,
+                             cap_uly - cos_angle * cap_result.height,
+                             cap_uly + sin_angle * cap_width - cos_angle * cap_result.height
+                            ] if captioned)
+                         ].minmax
+
+          padding = 4 * style.width
+          rect = [min_x - padding, min_y - padding, max_x + padding, max_y + padding]
+          @annot[:Rect] = rect
+          form[:BBox] = rect.dup
+
+          # Set the appropriate graphics state and transform the canvas so that the line is
+          # unrotated and its start point at the origin.
+          canvas = form.canvas(translate: false)
+          canvas.opacity(**opacity.to_h)
+          canvas.stroke_color(style.color) if style.color
+          canvas.fill_color(@annot.interior_color) if @annot.interior_color
+          canvas.line_width(style.width)
+          canvas.line_dash_pattern(style.style) if style.style.kind_of?(Array)
+          canvas.transform(cos_angle, sin_angle, -sin_angle, cos_angle, x0, y0)
+
+          stroke_op = (style.color ? :stroke : :end_path)
+          fill_op = (style.color && @annot.interior_color ? :fill_stroke :
+                       (style.color ? :stroke : :fill))
+
+          # Draw leader lines and line
+          if ll != 0
+            canvas.line(0, ll_sign * llo, 0, ll_y)
+            canvas.line(line_length, ll_sign * llo, line_length, ll_y)
+          end
+          if captioned && cap_position == :inline
+            canvas.line(0, line_y, [[0, cap_x].max, line_length].min, line_y)
+            canvas.line([[cap_x + cap_width, 0].max, line_length].min, line_y, line_length, line_y)
+          else
+            canvas.line(0, line_y, line_length, line_y)
+          end
+          canvas.send(stroke_op)
+
+          # Draw line endings
+          if line_ending_style.start_style != :none
+            do_fill = draw_line_ending(canvas, line_ending_style.start_style, 0, line_y,
+                                       style.width, 0)
+            canvas.send(do_fill ? fill_op : stroke_op)
+          end
+          if line_ending_style.end_style != :none
+            do_fill = draw_line_ending(canvas, line_ending_style.end_style, line_length, line_y,
+                                       style.width, Math::PI)
+            canvas.send(do_fill ? fill_op : stroke_op)
+          end
+
+          # Draw caption, adding half of the padding added to cap_width
+          cap_result.draw(canvas, cap_x + 1, cap_y) if captioned
+        end
+
+        # Creates the appropriate appearance for a square or circle annotation depending on the
+        # given +type+ (which can either be +:square+ or +:circle+).
+        #
+        # The cloudy border effect is not supported.
+        #
+        # See: HexaPDF::Type::Annotations::Square, HexaPDF::Type::Annotations::Circle
+        def create_square_circle_appearance(type)
+          # Prepare the annotation
+          form = (@annot[:AP] ||= {})[:N] ||=
+            @document.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, 0, 0]})
+          form.contents = ""
+          @annot.flag(:print)
+          @annot.unflag(:hidden)
+
+          rect = @annot[:Rect]
+          x, y, w, h = rect.left, rect.bottom, rect.width, rect.height
+          border_style = @annot.border_style
+          interior_color = @annot.interior_color
+          opacity = @annot.opacity
+
+          # Take the differences array into account. If it exists, the boundary of the actual
+          # rectangle is the one with the differences applied to /Rect.
+          #
+          # If the differences array doesn't exist, we assume that the /Rect is the rectangle we
+          # want to draw, with the line width split on both side (like with Canvas#rectangle). In
+          # this case we need to update /Rect accordingly so that the line width on the outside is
+          # correctly shown.
+          line_width_adjustment = border_style.width / 2.0
+          if (rd = @annot[:RD])
+            x += rd[0]
+            y += rd[3]
+            w -= rd[0] + rd[2]
+            h -= rd[1] + rd[3]
+          else
+            @annot[:RD] = [0, 0, 0, 0]
+            x = rect.left -= line_width_adjustment
+            y = rect.bottom -= line_width_adjustment
+            w = rect.width += line_width_adjustment
+            h = rect.height += line_width_adjustment
+          end
+          x += line_width_adjustment
+          y += line_width_adjustment
+          w -= 2 * line_width_adjustment
+          h -= 2 * line_width_adjustment
+
+          x -= rect.left
+          y -= rect.bottom
+          form[:BBox] = [0, 0, rect.width, rect.height]
+
+          if border_style.color || interior_color
+            canvas = form.canvas
+            canvas.opacity(**opacity.to_h)
+            canvas.stroke_color(border_style.color) if border_style.color
+            canvas.fill_color(interior_color) if interior_color
+            canvas.line_width(border_style.width)
+            canvas.line_dash_pattern(border_style.style) if border_style.style.kind_of?(Array)
+
+            if type == :square
+              canvas.rectangle(x, y, w, h)
+            else
+              canvas.ellipse(x + w / 2.0, y + h / 2.0, a: w / 2.0, b: h / 2.0)
+            end
+
+            if border_style.color && interior_color
+              canvas.fill_stroke
+            elsif border_style.color
+              canvas.stroke
+            else
+              canvas.fill
+            end
+          end
+        end
+
+        # Draws the line ending style +type+ at the position (+x+, +y+) and returns +true+ if the
+        # shape needs to be filled.
+        #
+        # The argument +angle+ specifies the angle at which the line ending style should be drawn.
+        #
+        # The +line_width+ is needed because the size of the line ending depends on it.
+        def draw_line_ending(canvas, type, x, y, line_width, angle)
+          lw3 = 3 * line_width
+
+          case type
+          when :square
+            canvas.rectangle(x - lw3, y - lw3, 2 * lw3, 2 * lw3)
+            true
+          when :circle
+            canvas.circle(x, y, lw3)
+            true
+          when :diamond
+            canvas.polygon(x + lw3, y, x, y + lw3, x - lw3, y, x, y - lw3)
+            true
+          when :open_arrow, :closed_arrow, :ropen_arrow, :rclosed_arrow
+            arrow_cos = Math.cos(Math::PI / 6 + angle)
+            arrow_sin = Math.sin(Math::PI / 6 + angle)
+            dir = (type == :ropen_arrow || type == :rclosed_arrow ? -1 : 1)
+            canvas.polyline(x + dir * arrow_cos * 3 * lw3, y + arrow_sin * 3 * lw3, x, y,
+                            x + dir * arrow_cos * 3 * lw3, y - arrow_sin * 3 * lw3)
+            if type == :closed_arrow || type == :rclosed_arrow
+              canvas.close_subpath
+              true
+            else
+              false
+            end
+          when :butt
+            canvas.line(x, y + lw3, x, y - lw3)
+            false
+          when :slash
+            sin_60 = Math.sin(Math::PI / 3)
+            cos_60 = Math.cos(Math::PI / 3)
+            canvas.line(x + cos_60 * lw3, y + sin_60 * lw3, x - cos_60 * lw3, y - sin_60 * lw3)
+            false
+          end
+        end
+
+      end
+
+    end
+  end
+end