acro_that 0.1.8 → 1.0.1

data/lib/acro_that/actions/update_field.rb

@@ -48,9 +48,8 @@ module AcroThat
           # Check if new_value looks like base64 image data or data URI
           image_data = @new_value
           if image_data && 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}$})))
-            # Try adding signature appearance
-            action = Actions::AddSignatureAppearance.new(@document, fld.ref, image_data)
-            result = action.call
+            # Try adding signature appearance using Signature field class
+            result = AcroThat::Fields::Signature.add_appearance(@document, fld.ref, image_data)
             return result if result
             # If appearance fails, fall through to normal update
           end
@@ -143,17 +142,18 @@ module AcroThat
             end
           end
 
-          # Only create checkbox appearances (not radio buttons)
-          unless is_radio
+          if is_radio
+            # For radio buttons, update all widget appearances (overwrite existing)
+            update_radio_button_appearances(field_ref)
+          else
+            # For checkboxes, create/update appearance
             widget_ref = find_checkbox_widget(fld.ref)
             if widget_ref
               widget_body = get_object_body_with_patch(widget_ref)
-              # Create appearances if /AP doesn't exist
-              unless widget_body&.include?("/AP")
-                rect = extract_widget_rect(widget_body)
-                if rect && rect[:width].positive? && rect[:height].positive?
-                  add_checkbox_appearance(widget_ref, rect[:width], rect[:height])
-                end
+              # Create appearances if /AP doesn't exist, or overwrite if it does
+              rect = extract_widget_rect(widget_body)
+              if rect && rect[:width].positive? && rect[:height].positive?
+                add_checkbox_appearance(widget_ref, rect[:width], rect[:height])
               end
             end
           end
@@ -178,8 +178,34 @@ module AcroThat
         ft_pattern = %r{/FT\s+/Btn}
         is_button_field = ft_pattern.match(dict_body)
 
-        normalized_value = if is_button_field
-                             # For checkboxes/radio buttons, normalize to "Yes" or "Off"
+        # Check if it's a radio button by checking field flags
+        # For widgets, check the parent field's flags since widgets don't have /Ff directly
+        is_radio = false
+        if is_button_field
+          field_flags_match = dict_body.match(%r{/Ff\s+(\d+)})
+          if field_flags_match
+            field_flags = field_flags_match[1].to_i
+            # Radio button flag is bit 15 = 32768
+            is_radio = field_flags.anybits?(32_768)
+          elsif dict_body.include?("/Parent")
+            # This is a widget - check parent field's flags
+            parent_tok = DictScan.value_token_after("/Parent", dict_body)
+            if parent_tok && parent_tok =~ /\A(\d+)\s+(\d+)\s+R/
+              parent_ref = [Integer(::Regexp.last_match(1)), Integer(::Regexp.last_match(2))]
+              parent_body = get_object_body_with_patch(parent_ref)
+              if parent_body
+                parent_flags_match = parent_body.match(%r{/Ff\s+(\d+)})
+                if parent_flags_match
+                  parent_flags = parent_flags_match[1].to_i
+                  is_radio = parent_flags.anybits?(32_768)
+                end
+              end
+            end
+          end
+        end
+
+        normalized_value = if is_button_field && !is_radio
+                             # For checkboxes, normalize to "Yes" or "Off"
                              # Accept "Yes", "/Yes" (PDF name format), true (boolean), or "true" (string)
                              value_str = new_value.to_s
                              is_checked = ["Yes", "/Yes", "true"].include?(value_str) || new_value == true
@@ -189,7 +215,13 @@ module AcroThat
                            end
 
         # Encode the normalized value
-        v_token = DictScan.encode_pdf_string(normalized_value)
+        # For checkboxes, use PDF name format to match /AS appearance state format
+        # For radio buttons and other fields, use PDF string format
+        v_token = if is_button_field && !is_radio
+                    DictScan.encode_pdf_name(normalized_value)
+                  else
+                    DictScan.encode_pdf_string(normalized_value)
+                  end
 
         # Find /V using pattern matching to ensure we get the complete key
         v_key_pattern = %r{/V(?=[\s(<\[/])}
@@ -338,9 +370,14 @@ module AcroThat
         return unless af_ref
 
         acro_body = get_object_body_with_patch(af_ref)
-        return if acro_body.include?("/NeedAppearances")
-
-        acro_patched = DictScan.upsert_key_value(acro_body, "/NeedAppearances", "true")
+        # Set /NeedAppearances false to use our custom appearance streams
+        # If we set it to true, viewers will ignore our custom appearances and generate defaults
+        # (e.g., circular radio buttons instead of our square checkboxes)
+        acro_patched = if acro_body.include?("/NeedAppearances")
+                         DictScan.replace_key_value(acro_body, "/NeedAppearances", "false")
+                       else
+                         DictScan.upsert_key_value(acro_body, "/NeedAppearances", "false")
+                       end
         apply_patch(af_ref, acro_patched, acro_body)
       end
 
@@ -396,6 +433,76 @@ module AcroThat
         nil
       end
 
+      def update_radio_button_appearances(parent_ref)
+        # Find all widgets that are children of this parent field
+        widgets = []
+
+        # Check patches first
+        patches = @document.instance_variable_get(:@patches)
+        patches.each do |patch|
+          next unless patch[:body]
+          next unless DictScan.is_widget?(patch[:body])
+
+          next unless patch[:body] =~ %r{/Parent\s+(\d+)\s+(\d+)\s+R}
+
+          widget_parent_ref = [Integer(::Regexp.last_match(1)), Integer(::Regexp.last_match(2))]
+          if widget_parent_ref == parent_ref
+            widgets << patch[:ref]
+          end
+        end
+
+        # Also check resolver (for existing widgets)
+        resolver.each_object do |ref, body|
+          next unless body && DictScan.is_widget?(body)
+
+          next unless body =~ %r{/Parent\s+(\d+)\s+(\d+)\s+R}
+
+          widget_parent_ref = [Integer(::Regexp.last_match(1)), Integer(::Regexp.last_match(2))]
+          if (widget_parent_ref == parent_ref) && !widgets.include?(ref)
+            widgets << ref
+          end
+        end
+
+        # Update appearance for each widget using Radio class method
+        widgets.each do |widget_ref|
+          widget_body = get_object_body_with_patch(widget_ref)
+          next unless widget_body
+
+          # Get widget dimensions
+          rect = extract_widget_rect(widget_body)
+          next unless rect && rect[:width].positive? && rect[:height].positive?
+
+          # Get export value from widget's /AP /N dictionary
+          export_value = nil
+          if widget_body.include?("/AP")
+            ap_tok = DictScan.value_token_after("/AP", widget_body)
+            if ap_tok && ap_tok.start_with?("<<")
+              n_tok = DictScan.value_token_after("/N", ap_tok)
+              if n_tok && n_tok.start_with?("<<")
+                # Extract export value (not /Off)
+                export_values = n_tok.scan(%r{/([^\s<>\[\]]+)\s+\d+\s+\d+\s+R}).flatten.reject { |v| v == "Off" }
+                export_value = export_values.first if export_values.any?
+              end
+            end
+          end
+
+          # If no export value found, generate one
+          export_value ||= "widget_#{widget_ref[0]}"
+
+          # Create a Radio instance to reuse appearance creation logic
+          radio_handler = AcroThat::Fields::Radio.new(@document, "", { width: rect[:width], height: rect[:height] })
+          radio_handler.send(
+            :add_radio_button_appearance,
+            widget_ref[0],
+            export_value,
+            0, 0, # x, y not needed when overwriting
+            rect[:width],
+            rect[:height],
+            parent_ref
+          )
+        end
+      end
+
       def extract_widget_rect(widget_body)
         return nil unless widget_body
 
@@ -470,34 +577,57 @@ module AcroThat
       end
 
       def create_checkbox_yes_appearance(width, height)
-        # Create a form XObject that draws a checked checkbox
-        # Box outline + checkmark
-        # Scale to match width and height
-        # Simple appearance: draw a box and a checkmark
-        # For simplicity, use PDF drawing operators
-        # Box: rectangle from (0,0) to (width, height)
-        # Checkmark: simple path drawing
-
-        # PDF content stream for checked checkbox
-        # Draw just the checkmark (no box border)
+        line_width = [width * 0.05, height * 0.05].min
         border_width = [width * 0.08, height * 0.08].min
 
-        # Calculate checkmark path
-        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
+        # Define checkmark in normalized coordinates (0-1 range) for consistent aspect ratio
+        # Checkmark shape: three points forming a checkmark
+        norm_x1 = 0.25
+        norm_y1 = 0.55
+        norm_x2 = 0.45
+        norm_y2 = 0.35
+        norm_x3 = 0.75
+        norm_y3 = 0.85
+
+        # Calculate scale to maximize size while maintaining aspect ratio
+        # Use the smaller dimension to ensure it fits
+        scale = [width, height].min * 0.85  # Use 85% of the smaller dimension
+        
+        # Calculate checkmark dimensions
+        check_width = scale
+        check_height = scale
+        
+        # Center the checkmark in the box
+        offset_x = (width - check_width) / 2
+        offset_y = (height - check_height) / 2
+        
+        # Calculate actual coordinates
+        check_x1 = offset_x + norm_x1 * check_width
+        check_y1 = offset_y + norm_y1 * check_height
+        check_x2 = offset_x + norm_x2 * check_width
+        check_y2 = offset_y + norm_y2 * check_height
+        check_x3 = offset_x + norm_x3 * check_width
+        check_y3 = offset_y + norm_y3 * check_height
 
         content_stream = "q\n"
-        content_stream += "0 0 0 rg\n" # Black color (darker)
-        content_stream += "#{border_width} w\n" # Line width
-        # Draw checkmark only (no box border)
+        # Draw square border around field bounds
+        content_stream += "0 0 0 RG\n" # Black stroke color
+        content_stream += "#{line_width} w\n" # Line width
+        # Draw rectangle from (0,0) to (width, height)
+        content_stream += "0 0 m\n"
+        content_stream += "#{width} 0 l\n"
+        content_stream += "#{width} #{height} l\n"
+        content_stream += "0 #{height} l\n"
+        content_stream += "0 0 l\n"
+        content_stream += "S\n" # Stroke the border
+
+        # Draw checkmark
+        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
+        content_stream += "S\n" # Stroke the checkmark
         content_stream += "Q\n"
 
         build_form_xobject(content_stream, width, height)

data/lib/acro_that/dict_scan.rb

@@ -130,6 +130,32 @@ module AcroThat
       end
     end
 
+    # Encode a string as a PDF name, escaping special characters with hex encoding
+    # PDF names must escape: # ( ) < > [ ] { } / % and control characters
+    # Example: "(Two Hr) Priority 2" becomes "/#28Two Hr#29 Priority 2"
+    def encode_pdf_name(name)
+      name_str = name.to_s
+      # Remove leading / if present (we'll add it back)
+      name_str = name_str[1..] if name_str.start_with?("/")
+
+      # Encode special characters as hex
+      encoded = name_str.each_byte.map do |byte|
+        char = byte.chr
+        # PDF name special characters that need hex encoding: # ( ) < > [ ] { } / %
+        # Also encode control characters (0x00-0x1F, 0x7F) and non-ASCII (0x80-0xFF)
+        if ["#", "(", ")", "<", ">", "[", "]", "{", "}", "/", "%"].include?(char) ||
+           byte.between?(0x00, 0x1F) || byte == 0x7F || byte.between?(0x80, 0xFF)
+          # Hex encode: # followed by 2-digit hex
+          "##{byte.to_s(16).upcase.rjust(2, '0')}"
+        else
+          # Regular printable ASCII: use as-is
+          char
+        end
+      end.join
+
+      "/#{encoded}"
+    end
+
     # Format a metadata key as a PDF dictionary key (ensure it starts with /)
     def format_pdf_key(key)
       key_str = key.to_s

data/lib/acro_that/document.rb

@@ -28,6 +28,8 @@ module AcroThat
       @raw = extract_pdf_from_form_data(raw_bytes).freeze
       @resolver = AcroThat::ObjectResolver.new(@raw)
       @patches = []
+      # Track radio button groups: group_id -> parent_field_ref
+      @radio_groups = {}
     end
 
     # Flatten this document to remove incremental updates
@@ -35,18 +37,27 @@ module AcroThat
       root_ref = @resolver.root_ref
       raise "Cannot flatten: no /Root found" unless root_ref
 
-      objects = []
+      # First pass: collect only references (lightweight) and find max_obj_num
+      # This avoids loading all object bodies into memory at once
+      refs = []
+      max_obj_num = 0
       @resolver.each_object do |ref, body|
-        objects << { ref: ref, body: body } if body
+        if body
+          refs << ref
+          max_obj_num = [max_obj_num, ref[0]].max
+        end
       end
 
-      objects.sort_by! { |obj| obj[:ref][0] }
+      # Sort references by object number
+      refs.sort_by! { |ref| ref[0] }
 
+      # Second pass: write objects in sorted order, retrieving bodies on demand
       writer = PDFWriter.new
       writer.write_header
 
-      objects.each do |obj|
-        writer.write_object(obj[:ref], obj[:body])
+      refs.each do |ref|
+        body = @resolver.object_body(ref)
+        writer.write_object(ref, body) if body
       end
 
       writer.write_xref
@@ -58,7 +69,6 @@ module AcroThat
       end
 
       # Write trailer
-      max_obj_num = objects.map { |obj| obj[:ref][0] }.max || 0
       writer.write_trailer(max_obj_num + 1, root_ref, info_ref)
 
       writer.output
@@ -381,9 +391,11 @@ module AcroThat
       all_fields = list_fields
 
       if block_given?
-        # Use block to determine which fields to keep
+        # Use block to determine which fields to remove
+        # Block receives field object (can check field.name, field.value, etc.)
+        # Return true to remove the field, false to keep it
         all_fields.each do |field|
-          fields_to_remove.add(field.name) unless yield(field.name)
+          fields_to_remove.add(field.name) if yield(field)
         end
       elsif keep_fields
         # Keep only specified fields
@@ -443,19 +455,28 @@ module AcroThat
         end
       end
 
-      # Collect objects to write (excluding removed fields and widgets)
-      objects = []
+      # Collect refs to write (excluding removed fields and widgets)
+      # Store refs only initially to avoid loading all bodies into memory at once
+      refs_to_keep = []
       @resolver.each_object do |ref, body|
         next if field_refs_to_remove.include?(ref)
         next if widget_refs_to_remove.include?(ref)
         next unless body
 
-        objects << { ref: ref, body: body }
+        refs_to_keep << ref
+      end
+
+      # Build objects hash - load bodies only for objects we need to modify
+      # For unmodified objects, we'll load bodies on demand during writing
+      objects = []
+      refs_to_keep.each do |ref|
+        body = @resolver.object_body(ref)
+        objects << { ref: ref, body: body } if body
       end
 
       # Process AcroForm to remove field references from /Fields array
       af_ref = acroform_ref
-      if af_ref
+      if af_ref && refs_to_keep.include?(af_ref)
         # Find the AcroForm object in our objects list
         af_obj = objects.find { |o| o[:ref] == af_ref }
         if af_obj