acro_that 0.1.8 → 1.0.0

data/lib/acro_that/fields/radio.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module AcroThat
+  module Fields
+    # Handles radio button field creation
+    class Radio
+      include Base
+
+      attr_reader :field_obj_num
+
+      def call
+        @field_value = @field_value.to_s.gsub(" ", "")
+        group_id = @options[:group_id]
+        radio_groups = @document.instance_variable_get(:@radio_groups)
+        parent_ref = radio_groups[group_id]
+
+        if parent_ref
+          # Subsequent radio button: add widget to existing parent's Kids array
+          add_subsequent_widget(parent_ref)
+        else
+          # First radio button in group: create parent field and first widget
+          create_first_widget(group_id, radio_groups)
+        end
+
+        true
+      end
+
+      private
+
+      def add_subsequent_widget(parent_ref)
+        widget_obj_num = next_fresh_object_number
+        page_ref = find_page_ref(page_num)
+
+        widget_body = create_widget_annotation_with_parent(widget_obj_num, parent_ref, page_ref, x, y, width,
+                                                           height, @field_type, @field_value, is_radio: true)
+
+        document.instance_variable_get(:@patches) << { ref: [widget_obj_num, 0], body: widget_body }
+
+        add_widget_to_parent_kids(parent_ref, widget_obj_num)
+        add_field_to_acroform_with_defaults(widget_obj_num)
+        add_widget_to_page(widget_obj_num, page_num)
+
+        add_radio_button_appearance(widget_obj_num, @field_value, x, y, width, height, parent_ref)
+
+        @field_obj_num = parent_ref[0]
+      end
+
+      def create_first_widget(group_id, radio_groups)
+        @field_obj_num = next_fresh_object_number
+        widget_obj_num = @field_obj_num + 1
+
+        field_body = create_field_dictionary(@field_value, @field_type)
+        page_ref = find_page_ref(page_num)
+
+        widget_body = create_widget_annotation_with_parent(widget_obj_num, [@field_obj_num, 0], page_ref, x, y, width,
+                                                           height, @field_type, @field_value, is_radio: true)
+
+        document.instance_variable_get(:@patches) << { ref: [@field_obj_num, 0], body: field_body }
+        document.instance_variable_get(:@patches) << { ref: [widget_obj_num, 0], body: widget_body }
+
+        add_widget_to_parent_kids([@field_obj_num, 0], widget_obj_num)
+        add_field_to_acroform_with_defaults(@field_obj_num)
+        add_field_to_acroform_with_defaults(widget_obj_num)
+        add_widget_to_page(widget_obj_num, page_num)
+
+        add_radio_button_appearance(widget_obj_num, @field_value, x, y, width, height, [@field_obj_num, 0])
+
+        radio_groups[group_id] = [@field_obj_num, 0]
+      end
+
+      def add_radio_button_appearance(widget_obj_num, export_value, _x, _y, width, height, parent_ref = nil)
+        widget_ref = [widget_obj_num, 0]
+        original_widget_body = get_object_body_with_patch(widget_ref)
+        return unless original_widget_body
+
+        # Store original before modifying to avoid loading again
+        widget_body = original_widget_body + ""
+
+        # Ensure we have a valid export value - if empty, generate a unique one
+        # Export value must be unique for each widget in the group for mutual exclusivity
+        if export_value.nil? || export_value.to_s.empty?
+          # Generate unique export value based on widget object number
+          export_value = "widget_#{widget_obj_num}"
+        end
+
+        # Encode export value as PDF name (escapes special characters like parentheses)
+        export_name = DictScan.encode_pdf_name(export_value)
+
+        unchecked_obj_num = next_fresh_object_number
+        unchecked_body = create_radio_unchecked_appearance(width, height)
+        document.instance_variable_get(:@patches) << { ref: [unchecked_obj_num, 0], body: unchecked_body }
+
+        checked_obj_num = next_fresh_object_number
+        checked_body = create_radio_checked_appearance(width, height)
+        document.instance_variable_get(:@patches) << { ref: [checked_obj_num, 0], body: checked_body }
+
+        widget_ap_dict = "<<\n  /N <<\n    /Off #{unchecked_obj_num} 0 R\n    #{export_name} #{checked_obj_num} 0 R\n  >>\n>>"
+
+        widget_body = if widget_body.include?("/AP")
+                        DictScan.replace_key_value(widget_body, "/AP", widget_ap_dict)
+                      else
+                        DictScan.upsert_key_value(widget_body, "/AP", widget_ap_dict)
+                      end
+
+        # Determine if this button should be selected by default
+        # Only set selected if the selected option is explicitly set to true
+        should_be_selected = [true, "true"].include?(@options[:selected])
+
+        as_value = should_be_selected ? export_name : "/Off"
+        widget_body = if widget_body.include?("/AS")
+                        DictScan.replace_key_value(widget_body, "/AS", as_value)
+                      else
+                        DictScan.upsert_key_value(widget_body, "/AS", as_value)
+                      end
+
+        # Use stored original_widget_body instead of loading again
+        apply_patch(widget_ref, widget_body, original_widget_body)
+
+        # Track original_parent_body outside blocks so we can reuse it
+        original_parent_body = nil
+
+        # Update parent field's /V if this button is selected by default
+        if parent_ref && should_be_selected
+          original_parent_body = get_object_body_with_patch(parent_ref)
+          if original_parent_body
+            # Store original before modifying
+            parent_body = original_parent_body + ""
+            # Update parent's /V to match the selected button's export value
+            parent_body = if parent_body.include?("/V")
+                            DictScan.replace_key_value(parent_body, "/V", export_name)
+                          else
+                            DictScan.upsert_key_value(parent_body, "/V", export_name)
+                          end
+            # Use stored original_parent_body instead of loading again
+            apply_patch(parent_ref, parent_body, original_parent_body)
+          end
+        end
+
+        # Update parent field's /AP if parent_ref is provided
+        if parent_ref
+          # Reuse original_parent_body if we already loaded it, otherwise load it
+          original_parent_body_for_ap = original_parent_body || get_object_body_with_patch(parent_ref)
+          return unless original_parent_body_for_ap
+
+          # Use a working copy for modification
+          parent_body_for_ap = original_parent_body_for_ap + ""
+          parent_ap_tok = DictScan.value_token_after("/AP", parent_body_for_ap)
+          if parent_ap_tok && parent_ap_tok.start_with?("<<")
+            n_tok = DictScan.value_token_after("/N", parent_ap_tok)
+            if n_tok && n_tok.start_with?("<<") && !n_tok.include?(export_name.to_s)
+              new_n_tok = n_tok.chomp(">>") + "  #{export_name} #{checked_obj_num} 0 R\n>>"
+              new_ap_tok = parent_ap_tok.sub(n_tok) { |_| new_n_tok }
+              new_parent_body = parent_body_for_ap.sub(parent_ap_tok) { |_| new_ap_tok }
+              apply_patch(parent_ref, new_parent_body, original_parent_body_for_ap)
+            end
+          else
+            ap_dict = "<<\n  /N <<\n    #{export_name} #{checked_obj_num} 0 R\n    /Off #{unchecked_obj_num} 0 R\n  >>\n>>"
+            new_parent_body = DictScan.upsert_key_value(parent_body_for_ap, "/AP", ap_dict)
+            apply_patch(parent_ref, new_parent_body, original_parent_body_for_ap)
+          end
+        end
+      end
+
+      def create_radio_checked_appearance(width, height)
+        # Draw only the checkmark (no border)
+        border_width = [width * 0.08, height * 0.08].min
+
+        check_x1 = width * 0.25
+        check_y1 = height * 0.45
+        check_x2 = width * 0.45
+        check_y2 = height * 0.25
+        check_x3 = width * 0.75
+        check_y3 = height * 0.75
+
+        content_stream = "q\n"
+        # Draw checkmark only (no border)
+        content_stream += "0 0 0 rg\n" # Black fill color
+        content_stream += "#{border_width} w\n" # Line width for checkmark
+        content_stream += "#{check_x1} #{check_y1} m\n"
+        content_stream += "#{check_x2} #{check_y2} l\n"
+        content_stream += "#{check_x3} #{check_y3} l\n"
+        content_stream += "S\n" # Stroke the checkmark
+        content_stream += "Q\n"
+
+        build_form_xobject(content_stream, width, height)
+      end
+
+      def create_radio_unchecked_appearance(width, height)
+        # Empty appearance (no border, no checkmark)
+        content_stream = "q\n"
+        # Empty appearance for unchecked state
+        content_stream += "Q\n"
+
+        build_form_xobject(content_stream, width, height)
+      end
+    end
+  end
+end

data/lib/acro_that/{actions/add_signature_appearance.rb → fields/signature.rb}

@@ -3,41 +3,60 @@
 require "chunky_png"
 
 module AcroThat
-  module Actions
-    # Action to add image appearance to a signature field
-    class AddSignatureAppearance
+  module Fields
+    # Handles signature field creation
+    class Signature
       include Base
 
-      def initialize(document, field_ref, image_data, width: nil, height: nil)
-        @document = document
-        @field_ref = field_ref
-        @image_data = image_data.is_a?(String) && image_data.start_with?("data:") ? decode_base64_data_uri(image_data) : decode_base64_if_needed(image_data)
-        @width = width
-        @height = height
+      attr_reader :field_obj_num
+
+      # Class method to add appearance to an existing signature field
+      # Can be called from both Signature field creation and UpdateField
+      def self.add_appearance(document, field_ref, image_data, width: nil, height: nil)
+        new(document, "", {}).add_appearance_to_field(field_ref, image_data, width: width, height: height)
       end
 
       def call
-        return false unless @field_ref && @image_data && !@image_data.empty?
+        @field_obj_num = next_fresh_object_number
+        widget_obj_num = @field_obj_num + 1
 
-        # Detect image format and dimensions
-        image_info = detect_image_format(@image_data)
-        return false unless image_info
+        field_body = create_field_dictionary(@field_value, @field_type)
+        page_ref = find_page_ref(page_num)
 
-        # Find widget annotation for this field
-        # First try: widget might be at field_obj_num + 1 (common pattern from AddField)
-        widget_ref = nil
-        if @field_ref[0] && @field_ref[1].zero?
-          potential_widget_ref = [@field_ref[0] + 1, 0]
-          potential_body = get_object_body_with_patch(potential_widget_ref)
-          # Check if it has /Parent pointing to our field - use regex directly for object references
-          if potential_body && DictScan.is_widget?(potential_body) && (potential_body =~ %r{/Parent\s+(\d+)\s+(\d+)\s+R})
-            parent_ref = [Integer(Regexp.last_match(1)), Integer(Regexp.last_match(2))]
-            widget_ref = potential_widget_ref if parent_ref == @field_ref
+        widget_body = create_widget_annotation_with_parent(widget_obj_num, [@field_obj_num, 0], page_ref, x, y, width,
+                                                           height, @field_type, @field_value)
+
+        document.instance_variable_get(:@patches) << { ref: [@field_obj_num, 0], body: field_body }
+        document.instance_variable_get(:@patches) << { ref: [widget_obj_num, 0], body: widget_body }
+
+        add_field_to_acroform_with_defaults(@field_obj_num)
+        add_widget_to_page(widget_obj_num, page_num)
+
+        # If this is a signature field with image data, add the signature appearance
+        if @field_value && !@field_value.empty?
+          image_data = @field_value
+          if image_data.is_a?(String) && (image_data.start_with?("data:image/") || (image_data.length > 50 && image_data.match?(%r{^[A-Za-z0-9+/]*={0,2}$})))
+            field_ref = [@field_obj_num, 0]
+            add_appearance_to_field(field_ref, image_data, width: width, height: height)
           end
         end
 
-        # If not found, use general search
-        widget_ref ||= find_widget_annotation(@field_ref)
+        true
+      end
+
+      def add_appearance_to_field(field_ref, image_data, width: nil, height: nil)
+        return false unless field_ref && image_data && !image_data.empty?
+
+        # Decode image data if needed
+        decoded_image_data = image_data.is_a?(String) && image_data.start_with?("data:") ? decode_base64_data_uri(image_data) : decode_base64_if_needed(image_data)
+        return false unless decoded_image_data && !decoded_image_data.empty?
+
+        # Detect image format and dimensions
+        image_info = detect_image_format(decoded_image_data)
+        return false unless image_info
+
+        # Find widget annotation for this field
+        widget_ref = find_signature_widget(field_ref)
         return false unless widget_ref
 
         widget_body = get_object_body_with_patch(widget_ref)
@@ -53,8 +72,8 @@ module AcroThat
         return false if rect_width <= 0 || rect_height <= 0
 
         # Get field dimensions (use provided width/height or field rect)
-        field_width = @width || rect_width
-        field_height = @height || rect_height
+        field_width = width || rect_width
+        field_height = height || rect_height
 
         # Get image natural dimensions
         image_width = image_info[:width].to_f
@@ -72,24 +91,27 @@ module AcroThat
 
         # Create Image XObject(s) - use natural image dimensions (not scaled)
         image_obj_num = next_fresh_object_number
-        image_result = create_image_xobject(image_obj_num, @image_data, image_info, image_width, image_height)
+        image_result = create_image_xobject(image_obj_num, decoded_image_data, image_info, image_width, image_height)
         image_body = image_result[:body]
         mask_obj_num = image_result[:mask_obj_num]
 
         # Create Form XObject (appearance stream) - use field dimensions for bounding box
-        # Image will be scaled and centered within the field bounds
         form_obj_num = mask_obj_num ? mask_obj_num + 1 : image_obj_num + 1
         form_body = create_form_xobject(form_obj_num, image_obj_num, field_width, field_height, scale_factor,
                                         scaled_width, scaled_height)
 
         # Queue new objects
-        patches << { ref: [image_obj_num, 0], body: image_body }
-        patches << { ref: [mask_obj_num, 0], body: image_result[:mask_body] } if mask_obj_num
-        patches << { ref: [form_obj_num, 0], body: form_body }
+        document.instance_variable_get(:@patches) << { ref: [image_obj_num, 0], body: image_body }
+        if mask_obj_num
+          document.instance_variable_get(:@patches) << { ref: [mask_obj_num, 0],
+                                                         body: image_result[:mask_body] }
+        end
+        document.instance_variable_get(:@patches) << { ref: [form_obj_num, 0], body: form_body }
 
         # Update widget annotation with /AP dictionary
-        # Get original body from resolver (not from patches) to ensure comparison works
-        original_widget_body = resolver.object_body(widget_ref)
+        # Use already-loaded widget_body as original (we already have it from line 62)
+        # Only reload if we don't have it (shouldn't happen, but for safety)
+        original_widget_body = widget_body || resolver.object_body(widget_ref)
         updated_widget = add_appearance_to_widget(widget_body, form_obj_num)
         apply_patch(widget_ref, updated_widget, original_widget_body)
 
@@ -99,14 +121,12 @@ module AcroThat
       private
 
       def decode_base64_data_uri(data_uri)
-        # Handle data:image/jpeg;base64,... format
         if data_uri =~ %r{^data:image/[^;]+;base64,(.+)$}
           Base64.decode64(Regexp.last_match(1))
         end
       end
 
       def decode_base64_if_needed(data)
-        # Check if it looks like base64
         if data.is_a?(String) && data.match?(%r{^[A-Za-z0-9+/]*={0,2}$})
           begin
             Base64.decode64(data)
@@ -128,7 +148,6 @@ module AcroThat
         # PNG: starts with 89 50 4E 47 0D 0A 1A 0A
         if data.bytesize >= 8 && data[0, 8] == "\x89PNG\r\n\x1A\n".b
           width, height = extract_png_dimensions(data)
-          # NOTE: filter will be determined in create_image_xobject after PNG is decoded
           return { format: :png, width: width, height: height, filter: "/FlateDecode" } if width && height
         end
 
@@ -136,9 +155,8 @@ module AcroThat
       end
 
       def extract_jpeg_dimensions(data)
-        i = 2 # Skip SOI marker
+        i = 2
         while i < data.bytesize - 9
-          # Look for SOF markers (0xFFC0, 0xFFC1, 0xFFC2, etc.)
           if data.getbyte(i) == 0xFF && (data.getbyte(i + 1) & 0xF0) == 0xC0 && (i + 8 < data.bytesize)
             height = (data.getbyte(i + 5) << 8) | data.getbyte(i + 6)
             width = (data.getbyte(i + 7) << 8) | data.getbyte(i + 8)
@@ -146,13 +164,10 @@ module AcroThat
           end
           i += 1
         end
-        # Fallback: if we can't find dimensions, return default 1x1 for minimal JPEGs
-        # This handles minimal/truncated JPEGs
         [1, 1]
       end
 
       def extract_png_dimensions(data)
-        # PNG dimensions are in first IHDR chunk at offset 16
         if data.bytesize >= 24
           width = data[16, 4].unpack1("N")
           height = data[20, 4].unpack1("N")
@@ -161,19 +176,17 @@ module AcroThat
         nil
       end
 
-      def find_widget_annotation(field_ref)
+      def find_signature_widget(field_ref)
         # First check patches (for newly created widgets)
-        patches.each do |patch|
+        document.instance_variable_get(:@patches).each do |patch|
           next unless patch[:body]
           next unless DictScan.is_widget?(patch[:body])
 
-          # Check if widget has /Parent pointing to field_ref - use regex directly
           if patch[:body] =~ %r{/Parent\s+(\d+)\s+(\d+)\s+R}
             parent_ref = [Integer(Regexp.last_match(1)), Integer(Regexp.last_match(2))]
             return patch[:ref] if parent_ref == field_ref
           end
 
-          # Also check if widget IS the field (flat structure) and has /FT /Sig
           if patch[:body].include?("/FT") && DictScan.value_token_after("/FT",
                                                                         patch[:body]) == "/Sig" && (patch[:ref] == field_ref)
             return patch[:ref]
@@ -184,13 +197,11 @@ module AcroThat
         resolver.each_object do |ref, body|
           next unless body && DictScan.is_widget?(body)
 
-          # Check if widget has /Parent pointing to field_ref - use regex directly
           if body =~ %r{/Parent\s+(\d+)\s+(\d+)\s+R}
             parent_ref = [Integer(Regexp.last_match(1)), Integer(Regexp.last_match(2))]
             return ref if parent_ref == field_ref
           end
 
-          # Also check if widget IS the field (flat structure) and has /FT /Sig
           if body.include?("/FT") && DictScan.value_token_after("/FT", body) == "/Sig" && (ref == field_ref)
             return ref
           end
@@ -215,13 +226,6 @@ module AcroThat
         { x1: values[0], y1: values[1], x2: values[2], y2: values[3] }
       end
 
-      def get_widget_rect_dimensions(widget_body)
-        rect = extract_rect(widget_body)
-        return nil unless rect
-
-        { width: rect[:x2] - rect[:x1], height: rect[:y2] - rect[:y1] }
-      end
-
       def create_image_xobject(obj_num, image_data, image_info, _width, _height)
         stream_data = nil
         filter = image_info[:filter]
@@ -230,19 +234,14 @@ module AcroThat
 
         case image_info[:format]
         when :jpeg
-          # JPEG can be embedded directly with DCTDecode (no transparency support in JPEG)
           stream_data = image_data.b
         when :png
-          # PNG needs to be decoded to raw RGB pixel data
           begin
             png = ChunkyPNG::Image.from_io(StringIO.new(image_data))
 
-            # Check if image has transparency
             has_transparency = if png.palette
-                                 # Indexed color PNG - check if palette has transparent color
                                  png.palette.include?(ChunkyPNG::Color::TRANSPARENT)
                                else
-                                 # True color PNG - check if any pixel has alpha < 255
                                  sample_size = [png.width * png.height, 1000].min
                                  step = [png.width * png.height / sample_size, 1].max
                                  has_alpha = false
@@ -261,20 +260,17 @@ module AcroThat
             width = png.width
             height = png.height
 
-            # Extract RGB pixel data (without compositing)
             rgb_data = +""
             alpha_data = +"" if has_transparency
 
             height.times do |y|
               width.times do |x|
                 color = png[x, y]
-                # Extract RGB components
                 r = ChunkyPNG::Color.r(color)
                 g = ChunkyPNG::Color.g(color)
                 b = ChunkyPNG::Color.b(color)
                 rgb_data << [r, g, b].pack("C*")
 
-                # Extract alpha channel for soft mask
                 if has_transparency
                   alpha = ChunkyPNG::Color.a(color)
                   alpha_data << [alpha].pack("C*")
@@ -282,11 +278,9 @@ module AcroThat
               end
             end
 
-            # Compress RGB data with FlateDecode
             stream_data = Zlib::Deflate.deflate(rgb_data)
             filter = "/FlateDecode"
 
-            # Create soft mask (alpha channel) if transparency is present
             if has_transparency && alpha_data
               mask_obj_num = obj_num + 1
               compressed_alpha = Zlib::Deflate.deflate(alpha_data)
@@ -307,7 +301,6 @@ module AcroThat
               mask_body += "\nendstream"
             end
           rescue StandardError
-            # If PNG decoding fails, fall back to trying raw data (won't work but prevents crash)
             stream_data = image_data.b
           end
         else
@@ -325,7 +318,6 @@ module AcroThat
         dict += "  /ColorSpace /DeviceRGB\n"
         dict += "  /Filter #{filter}\n"
         dict += "  /Length #{stream_length}\n"
-        # Add soft mask if transparency is present
         dict += "  /SMask #{mask_obj_num} 0 R\n" if mask_obj_num
         dict += ">>\n"
         dict += "stream\n"
@@ -337,23 +329,11 @@ module AcroThat
 
       def create_form_xobject(_obj_num, image_obj_num, field_width, field_height, _scale_factor, scaled_width,
                               scaled_height)
-        # Calculate offset to left-align the image horizontally and center vertically
-        offset_x = 0.0 # Left-aligned (no horizontal offset)
-        offset_y = (field_height - scaled_height) / 2.0 # Center vertically
-
-        # PDF content stream that draws the image
-        # q = save graphics state
-        # In PDF, when you draw an Image XObject with /Im1 Do, it draws a 1x1 unit square
-        # The /Width and /Height in the Image XObject define the pixel dimensions, not user space size
-        # To scale it to the desired size, we scale by scaled_width x scaled_height
-        # Then translate to center it within the field bounds
-        # Transformation matrix: [sx 0 0 sy tx ty] where sx=scaled_width, sy=scaled_height
-        # Format: [a b c d e f] where a=sx, d=sy, e=tx, f=ty
-        # Q = restore graphics state
+        offset_x = 0.0
+        offset_y = (field_height - scaled_height) / 2.0
+
         content_stream = "q\n"
-        # First translate to center position
         content_stream += "1 0 0 1 #{offset_x} #{offset_y} cm\n" if offset_x != 0 || offset_y != 0
-        # Then scale by scaled dimensions (this makes the 1x1 unit image become scaled_width x scaled_height)
         content_stream += "#{scaled_width} 0 0 #{scaled_height} 0 0 cm\n"
         content_stream += "/Im1 Do\n"
         content_stream += "Q"
@@ -373,22 +353,15 @@ module AcroThat
       end
 
       def add_appearance_to_widget(widget_body, form_obj_num)
-        # Add /AP << /N form_obj_num 0 R >> to widget
-        ap_entry = "/AP << /N #{form_obj_num} 0 R >>"
         new_ap_value = "<< /N #{form_obj_num} 0 R >>"
 
         if widget_body.include?("/AP")
-          # Extract the full /AP dictionary value (not just the opening <<)
-          # Find /AP key
           ap_key_match = widget_body.match(%r{/AP(?=[\s(<\[/])})
           return widget_body unless ap_key_match
 
-          # Find the start of the value (after /AP and whitespace)
           value_start = ap_key_match.end(0)
           value_start += 1 while value_start < widget_body.length && widget_body[value_start] =~ /\s/
 
-          # Extract the complete nested dictionary value
-          # Start with << and track depth to find matching >>
           depth = 0
           value_end = value_start
           while value_end < widget_body.length
@@ -404,17 +377,15 @@ module AcroThat
             end
           end
 
-          # Replace the complete /AP value
           before = widget_body[0...value_start]
           after = widget_body[value_end..]
           return "#{before}#{new_ap_value}#{after}"
         end
 
-        # Insert /AP before closing >>
         if widget_body.include?(">>")
-          widget_body.sub(/(\s*)>>\s*$/, "\\1#{ap_entry}\n\\1>>")
+          widget_body.sub(/(\s*)>>\s*$/, "\\1/AP #{new_ap_value}\n\\1>>")
         else
-          widget_body + " #{ap_entry}"
+          widget_body + " /AP #{new_ap_value}"
         end
       end
     end

data/lib/acro_that/fields/text.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module AcroThat
+  module Fields
+    # Handles text field creation
+    class Text
+      include Base
+
+      attr_reader :field_obj_num
+
+      def call
+        @field_obj_num = next_fresh_object_number
+        widget_obj_num = @field_obj_num + 1
+
+        field_body = create_field_dictionary(@field_value, @field_type)
+        page_ref = find_page_ref(page_num)
+
+        widget_body = create_widget_annotation_with_parent(widget_obj_num, [@field_obj_num, 0], page_ref, x, y, width,
+                                                           height, @field_type, @field_value)
+
+        document.instance_variable_get(:@patches) << { ref: [@field_obj_num, 0], body: field_body }
+        document.instance_variable_get(:@patches) << { ref: [widget_obj_num, 0], body: widget_body }
+
+        add_field_to_acroform_with_defaults(@field_obj_num)
+        add_widget_to_page(widget_obj_num, page_num)
+
+        true
+      end
+    end
+  end
+end

data/lib/acro_that/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AcroThat
-  VERSION = "0.1.8"
+  VERSION = "1.0.0"
 end

data/lib/acro_that.rb

@@ -15,12 +15,20 @@ require_relative "acro_that/field"
 require_relative "acro_that/page"
 require_relative "acro_that/document"
 
-# Load actions
+# Load actions base first (needed by fields)
 require_relative "acro_that/actions/base"
+
+# Load fields
+require_relative "acro_that/fields/base"
+require_relative "acro_that/fields/radio"
+require_relative "acro_that/fields/text"
+require_relative "acro_that/fields/checkbox"
+require_relative "acro_that/fields/signature"
+
+# Load actions
 require_relative "acro_that/actions/add_field"
 require_relative "acro_that/actions/update_field"
 require_relative "acro_that/actions/remove_field"
-require_relative "acro_that/actions/add_signature_appearance"
 
 module AcroThat
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acro_that
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 1.0.0
 platform: ruby
 authors:
 - Michael Wynkoop
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-04 00:00:00.000000000 Z
+date: 2025-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chunky_png
@@ -108,13 +108,17 @@ files:
 - issues/refactoring-opportunities.md
 - lib/acro_that.rb
 - lib/acro_that/actions/add_field.rb
-- lib/acro_that/actions/add_signature_appearance.rb
 - lib/acro_that/actions/base.rb
 - lib/acro_that/actions/remove_field.rb
 - lib/acro_that/actions/update_field.rb
 - lib/acro_that/dict_scan.rb
 - lib/acro_that/document.rb
 - lib/acro_that/field.rb
+- lib/acro_that/fields/base.rb
+- lib/acro_that/fields/checkbox.rb
+- lib/acro_that/fields/radio.rb
+- lib/acro_that/fields/signature.rb
+- lib/acro_that/fields/text.rb
 - lib/acro_that/incremental_writer.rb
 - lib/acro_that/object_resolver.rb
 - lib/acro_that/objstm.rb