pdfrb 0.3.0 → 0.6.0

data/lib/pdfrb/model/type/font_file3.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Type 3 font file stream — the modern container used for CFF
+      # (Compact Font Format), OpenType, and CID-keyed fonts.
+      # Referenced by FontDescriptor /FontFile3.
+      class FontFile3 < Pdfrb::Model::Cos::Stream
+        def subtype; self[:Subtype]&.to_sym; end
+
+        def font_program
+          decoded_stream&.force_encoding(Encoding::BINARY)
+        end
+
+        def cid_font_type0?; subtype == :CIDFontType0C; end
+        def open_type?; subtype == :OpenType; end
+        def type1c?; subtype == :Type1C; end
+        def truetype?; subtype == :TrueType; end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/font_multiple_master.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # MultipleMaster Type 1 font (s9.6.2.3). Type 1 font with
+      # additional design axes between masters. Deprecated in PDF 2.0.
+      class FontMultipleMaster < Font
+        def subtype; self[:Subtype]&.to_sym; end
+        def name; self[:Name]; end
+        def first_char; self[:FirstChar]; end
+        def last_char; self[:LastChar]; end
+        def widths; self[:Widths]; end
+        def font_descriptor; self[:FontDescriptor]; end
+        def encoding; self[:Encoding]; end
+        def blend_axis_types; self[:BlendAxisTypes]; end
+
+        def mm_type1?
+          subtype == :MMType1
+        end
+
+        def first_char_or_default
+          first_char || 0
+        end
+
+        def last_char_or_default
+          last_char || 255
+        end
+
+        def char_range
+          [first_char_or_default, last_char_or_default]
+        end
+      end
+
+      # CharProcMap (s9.6.4). Mapping from character names to the
+      # content-stream procedures that draw them, used by Type 3 fonts.
+      # The actual procedures live as streams under their names in a
+      # Tiling pattern's Resources.
+      class CharProcMap < Pdfrb::Model::Cos::Dictionary
+        def entries
+          value.each
+        end
+
+        def each_procedure(&block)
+          return enum_for(:each_procedure) unless block
+
+          value.each(&block)
+        end
+
+        def procedure_for(char_name)
+          value[char_name.to_sym] || value[char_name.to_s]
+        end
+
+        def has_glyph?(char_name)
+          !!procedure_for(char_name)
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/font_true_type.rb

@@ -4,7 +4,7 @@ module Pdfrb
   module Model
     module Type
       # TrueType font (s9.6.3). /Subtype /TrueType.
-      class FontTrueType < Pdfrb::Model::Cos::Dictionary
+      class FontTrueType < Pdfrb::Model::Type::Font
         arlington_object "FontTrueType"
       end
     end

data/lib/pdfrb/model/type/font_type0.rb

@@ -4,7 +4,7 @@ module Pdfrb
   module Model
     module Type
       # Type0 (composite) font (s9.7). Outer font that wraps a CIDFont.
-      class FontType0 < Pdfrb::Model::Cos::Dictionary
+      class FontType0 < Pdfrb::Model::Type::Font
         arlington_object "FontType0"
       end
     end

data/lib/pdfrb/model/type/font_type1.rb

@@ -4,7 +4,7 @@ module Pdfrb
   module Model
     module Type
       # Type1 font (s9.6.2). /Subtype /Type1.
-      class FontType1 < Pdfrb::Model::Cos::Dictionary
+      class FontType1 < Pdfrb::Model::Type::Font
         arlington_object "FontType1"
       end
     end

data/lib/pdfrb/model/type/font_type3.rb

@@ -5,7 +5,7 @@ module Pdfrb
     module Type
       # Type 3 glyph font (s9.6.5). /Subtype /Type3, /CharProcs,
       # /Resources, /FontBBox, /FontMatrix, /Encoding, /Widths.
-      class FontType3 < Pdfrb::Model::Cos::Dictionary
+      class FontType3 < Pdfrb::Model::Type::Font
         arlington_object "FontType3"
       end
     end

data/lib/pdfrb/model/type/form_field.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      class Field < Cos::Dictionary
+        register_type :Field
+
+        def field_type; self[:FT]; end
+        def field_name; self[:T]; end
+        def alternate_field_name; self[:TU]; end
+        def mapping_field_name; self[:TM]; end
+        def field_value; self[:V]; end
+        def default_value; self[:DV]; end
+        def kids; self[:Kids]; end
+        def parent; self[:Parent]; end
+        def flags; self[:Ff] || 0; end
+        def additional_actions; self[:AA]; end
+        def appearance_characteristics; self[:MK]; end
+
+        def button?; field_type&.to_sym == :Btn; end
+        def text?; field_type&.to_sym == :Tx; end
+        def choice?; field_type&.to_sym == :Ch; end
+        def signature?; field_type&.to_sym == :Sig; end
+
+        def read_only?; flags & 1 != 0; end
+        def required?; flags & 2 != 0; end
+        def no_export?; flags & 4 != 0; end
+
+        def has_kids?
+          kids && (!kids.is_a?(Array) || !kids.empty?)
+        end
+
+        def terminal_field?
+          !has_kids?
+        end
+
+        def resolved_parent
+          ref = parent
+          return nil unless ref && document
+
+          document.object(ref)
+        end
+
+        def root_field
+          cur = self
+          while cur&.parent
+            parent_ref = cur.parent
+            cur = if parent_ref.is_a?(Pdfrb::Model::Reference) && document
+                    document.object(parent_ref)
+                  else
+                    parent_ref
+                  end
+          end
+          cur
+        end
+
+        def fully_qualified_name
+          parts = []
+          cur = self
+          while cur
+            parts << cur.field_name if cur.field_name
+            parent_ref = cur.parent
+            break unless parent_ref && document
+
+            cur = document.object(parent_ref)
+          end
+          parts.reverse.join(".")
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/free_text_annotation.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Free-text annotation (s12.5.6.6). Text shown directly on the page.
+      class FreeTextAnnotation < MarkupAnnotation
+        def default_appearance; self[:DA]; end
+        def q; self[:Q]; end
+        def rc; self[:RC]; end
+        def ds; self[:DS]; end
+        def cl; self[:CL]; end
+        def it; self[:IT]; end
+        def be; self[:BE]; end
+        def rd; self[:RD]; end
+        def style_string; default_appearance; end
+
+        def text_alignment
+          case q
+          when 1 then :center
+          when 2 then :right
+          when 3 then :justify
+          else :left
+          end
+        end
+
+        def callout?
+          !!cl
+        end
+
+        def border_effect?
+          !!be
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/function.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # PDF Function dictionary (s8.9.1). Functions map input values to
+      # output values; used by shadings, color spaces, and other
+      # computational graphics primitives.
+      #
+      # Four function types exist (s8.9.4..7):
+      #   * Type 0: Sampled (N-dimensional lookup table)
+      #   * Type 2: Exponential (C0 + (C1 - C0) * t^r)
+      #   * Type 3: Stitching (concatenation of multiple subfunctions)
+      #   * Type 4: PostScript calculator (most flexible)
+      class Function < Pdfrb::Model::Cos::Dictionary
+        def function_type; self[:FunctionType]; end
+
+        def domain; self[:Domain]; end
+        def range; self[:Range]; end
+
+        def sampled?; function_type.zero?; end
+        def exponential?; function_type == 2; end
+        def stitching?; function_type == 3; end
+        def postscript?; function_type == 4; end
+
+        def input_dimension
+          return nil unless domain
+
+          arr = domain.is_a?(Pdfrb::Model::PdfArray) ? domain.to_a : domain
+          arr.is_a?(Array) ? arr.size / 2 : nil
+        end
+
+        def output_dimension
+          return nil unless range
+
+          arr = range.is_a?(Pdfrb::Model::PdfArray) ? range.to_a : range
+          arr.is_a?(Array) ? arr.size / 2 : nil
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/function_exponential.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Type 2 Exponential interpolation function (s8.9.4).
+      # Maps +t+ ∈ [0,1] to C0 + (C1 - C0) * t^N.
+      # Commonly used for 2-color linear gradients.
+      class FunctionExponential < Function
+        def c0; self[:C0]; end
+        def c1; self[:C1]; end
+        def exponent; self[:N] || 1; end
+
+        def linear?
+          exponent == 1
+        end
+
+        def evaluate(t)
+          return nil unless c0 && c1
+
+          arr0 = c0.is_a?(Pdfrb::Model::PdfArray) ? c0.to_a : c0
+          arr1 = c1.is_a?(Pdfrb::Model::PdfArray) ? c1.to_a : c1
+          n = exponent.to_f
+          arr0.each_with_index.map do |a, i|
+            a.to_f + ((arr1[i].to_f - a.to_f) * (t**n))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/function_postscript.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Type 4 PostScript calculator function (s8.9.6). Carries a
+      # PostScript program in the stream payload that computes the
+      # output values from input values.
+      class FunctionPostScript < Pdfrb::Model::Cos::Stream
+        def function_type; self[:FunctionType] || 4; end
+
+        def domain; self[:Domain]; end
+        def range; self[:Range]; end
+
+        def postscript?
+          true
+        end
+
+        def program
+          decoded_stream&.force_encoding(Encoding::BINARY)
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/function_sampled.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Type 0 Sampled function (s8.9.3). N-dimensional lookup table
+      # with interpolation. Carries sample data in the stream payload.
+      class FunctionSampled < Pdfrb::Model::Cos::Stream
+        def function_type; self[:FunctionType] || 0; end
+
+        def domain; self[:Domain]; end
+        def range; self[:Range]; end
+        def size; self[:Size]; end
+        def bits_per_sample; self[:BitsPerSample]; end
+        def encode; self[:Encode]; end
+        def decode; self[:Decode]; end
+
+        def sampled?
+          true
+        end
+
+        def input_dimension
+          return nil unless domain
+
+          arr = domain.is_a?(Pdfrb::Model::PdfArray) ? domain.to_a : domain
+          arr.is_a?(Array) ? arr.size / 2 : nil
+        end
+
+        def output_dimension
+          return nil unless range
+
+          arr = range.is_a?(Pdfrb::Model::PdfArray) ? range.to_a : range
+          arr.is_a?(Array) ? arr.size / 2 : nil
+        end
+
+        def sample_count
+          return 1 unless size
+
+          arr = size.is_a?(Pdfrb::Model::PdfArray) ? size.to_a : size
+          return 1 unless arr.is_a?(Array) && !arr.empty?
+
+          arr.reduce(1) { |product, n| product * n.to_i }
+        end
+
+        def bit_depth_8?
+          bits_per_sample == 8
+        end
+
+        def bit_depth_16?
+          bits_per_sample == 16
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/function_stitching.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Type 3 Stitching function (s8.9.5). Concatenates multiple
+      # sub-functions over a stitched input domain.
+      class FunctionStitching < Function
+        def sub_functions; self[:Functions]; end
+        def bounds; self[:Bounds]; end
+        def encode; self[:Encode]; end
+
+        def subfunction_count
+          return 0 unless sub_functions
+
+          arr = sub_functions.is_a?(Pdfrb::Model::PdfArray) ? sub_functions.to_a : sub_functions
+          arr.is_a?(Array) ? arr.size : 0
+        end
+
+        def each_subfunction
+          return enum_for(:each_subfunction) unless block_given?
+          return unless sub_functions && document
+
+          arr = sub_functions.is_a?(Pdfrb::Model::PdfArray) ? sub_functions.to_a : sub_functions
+          arr.each do |ref|
+            obj = ref.is_a?(Pdfrb::Model::Reference) ? document.object(ref) : ref
+            yield obj if obj
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/generic_appearance.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      class GenericAppearance
+        attr_reader :annotation, :document
+
+        def initialize(annotation, document)
+          @annotation = annotation
+          @document = document
+        end
+
+        def create_appearance
+          rect = annotation[:Rect]
+          return nil unless rect.is_a?(::Array) && rect.length == 4
+
+          x0, y0, x1, y1 = rect
+          width = (x1 - x0).abs
+          height = (y1 - y0).abs
+          return nil if width.zero? || height.zero?
+
+          stream = document.add(
+            {
+              Type: :XObject,
+              Subtype: :Form,
+              BBox: [0, 0, width, height],
+              Matrix: [1, 0, 0, 1, 0, 0],
+              Length: 0,
+            },
+            type: Pdfrb::Model::Cos::Stream
+          )
+          stream.stream = "q Q\n"
+          annotation[:AP] = { N: Pdfrb::Model::Reference.new(stream.oid, stream.gen) }
+          stream
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/graphics_state_parameter.rb

@@ -11,6 +11,75 @@ module Pdfrb
       class GraphicsStateParameter < Pdfrb::Model::Cos::Dictionary
         arlington_object "GraphicsStateParameter"
         register_type :ExtGState
+
+        def line_width; self[:LW]; end
+        def line_cap; self[:LC]; end
+        def line_join; self[:LJ]; end
+        def miter_limit; self[:ML]; end
+        def dash_pattern; self[:D]; end
+        def rendering_intent; self[:RI]; end
+        def stroke_adjustment?; truthy?(self[:SA]); end
+        def blend_mode; self[:BM]; end
+        def stroking_alpha; self[:CA]; end
+        def nonstroking_alpha; self[:ca]; end
+        def alpha_source?; truthy?(self[:AIS]); end
+        def overprint?; truthy?(self[:OP]); end
+        def nonstroking_overprint?; truthy?(self[:op]); end
+        def overprint_mode; self[:OPM]; end
+        def text_knockout?; truthy?(self[:TK]); end
+        def font; self[:Font]; end
+        def transfer_function; self[:TR]; end
+        def transfer_function2; self[:TR2]; end
+        def halftone; self[:HT]; end
+        def flatness; self[:FL]; end
+        def black_point_compensation; self[:UseBlackPtComp]; end
+        def soft_mask; self[:SMask]; end
+
+        def font_name
+          return nil unless font
+
+          arr = font.is_a?(Pdfrb::Model::PdfArray) ? font.to_a : font
+          arr.is_a?(Array) ? arr[0] : nil
+        end
+
+        def font_size
+          return nil unless font
+
+          arr = font.is_a?(Pdfrb::Model::PdfArray) ? font.to_a : font
+          arr.is_a?(Array) ? arr[1] : nil
+        end
+
+        def has_soft_mask?
+          !!soft_mask
+        end
+
+        def has_transparency?
+          (stroking_alpha && stroking_alpha != 1) ||
+            (nonstroking_alpha && nonstroking_alpha != 1) ||
+            !!blend_mode || !!soft_mask
+        end
+
+        def has_font?
+          !!font
+        end
+
+        def dash_array
+          return nil unless dash_pattern
+
+          arr = dash_pattern.is_a?(Pdfrb::Model::PdfArray) ? dash_pattern.to_a : dash_pattern
+          return nil unless arr.is_a?(Array) && arr.size >= 1
+
+          arr[0]
+        end
+
+        def dash_phase
+          return nil unless dash_pattern
+
+          arr = dash_pattern.is_a?(Pdfrb::Model::PdfArray) ? dash_pattern.to_a : dash_pattern
+          return nil unless arr.is_a?(Array) && arr.size >= 2
+
+          arr[1]
+        end
       end
     end
   end

data/lib/pdfrb/model/type/halftone.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Halftone dictionary (s8.7.4). Halftones control how continuous
+      # tones are simulated via dot patterns for printing. Six halftone
+      # types exist in the PDF spec.
+      class Halftone < Pdfrb::Model::Cos::Dictionary
+        def halftone_type; self[:HalftoneType]; end
+        def halftone_name; self[:HalftoneName]; end
+
+        def type1?; halftone_type == 1; end
+        def type5?; halftone_type == 5; end
+        def type6?; halftone_type == 6; end
+        def type10?; halftone_type == 10; end
+        def type16?; halftone_type == 16; end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/halftone_type1.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Type 1 halftone: a 1-bit tile sampled from a halftone screen
+      # cell defined by frequency, angle, and spot function.
+      class HalftoneType1 < Halftone
+        def frequency; self[:Frequency]; end
+        def angle; self[:Angle]; end
+        def spot_function; self[:SpotFunction]; end
+        def accurate_screens?; truthy?(self[:AccurateScreens]); end
+        def transfer_function; self[:TransferFunction]; end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/halftone_type10.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Type 10 halftone: mesh-based continuous-tone (PDF 1.4+, mostly
+      # used for non-square pixel grids).
+      class HalftoneType10 < HalftoneType6
+        def xsquarestep; self[:Xsquarestep]; end
+        def ysquarestep; self[:Ysquarestep]; end
+        def center_x; self[:CenterX]; end
+        def center_y; self[:CenterY]; end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/halftone_type16.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Type 16 halftone: more flexible mesh variant (PDF 1.4+).
+      class HalftoneType16 < HalftoneType10
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/halftone_type5.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Type 5 halftone: a dictionary mapping colorant name → HalftoneType1.
+      class HalftoneType5 < Halftone
+        def halftones; self[:Halftones]; end
+        def default; self[:Default]; end
+
+        def colorant_count
+          return 0 unless halftones
+
+          obj = if halftones.is_a?(Pdfrb::Model::Reference) && document
+                  document.object(halftones)
+                else
+                  halftones
+                end
+          obj.is_a?(Pdfrb::Model::Cos::Dictionary) ? obj.value.size : obj&.size || 0
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/halftone_type6.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Type 6 halftone: continuous-tone cell (PDF 1.4+).
+      class HalftoneType6 < Halftone
+        def width; self[:Width]; end
+        def height; self[:Height]; end
+        def width2; self[:Width2]; end
+        def height2; self[:Height2]; end
+        def transfer_function; self[:TransferFunction]; end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/highlight_annotation.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Highlight annotation. /Subtype /Highlight.
+      class HighlightAnnotation < TextMarkupAnnotation
+      end
+    end
+  end
+end