xlsxrb 0.1.14 → 0.1.16

data/lib/xlsxrb/ooxml/worksheet_writer.rb

@@ -24,11 +24,14 @@ module Xlsxrb
         result.freeze
       end.freeze
 
-      INTEGER_STRINGS = (0..65_535).map(&:to_s).freeze
+      INTEGER_STRINGS = (0..65_535).map { |n| -n.to_s }.freeze
 
-      def initialize(io, date1904: false)
+      attr_accessor :escape_formulas
+
+      def initialize(io, date1904: false, escape_formulas: false)
         @io = io
         @date1904 = date1904 ? true : false
+        @escape_formulas = escape_formulas ? true : false
         @builder = XmlBuilder.new(@io)
         @row_buffer = String.new(capacity: 65_536)
         @started = false
@@ -47,7 +50,7 @@ module Xlsxrb
       #   split_pane: { x_split:, y_split:, top_left_cell: }
       #   selection: { active_cell:, sqref:, pane: }
       #   sheet_view: Hash of sheet view properties
-      def start(columns: [], sheet_properties: nil, freeze_pane: nil, split_pane: nil, selection: nil, sheet_view: nil)
+      def start(columns: [], sheet_properties: nil, freeze_pane: nil, split_pane: nil, selection: nil, sheet_view: nil, sheet_format: nil)
         return if @started
 
         @started = true
@@ -59,12 +62,12 @@ module Xlsxrb
           columns.each do |col|
             if col.is_a?(Elements::Column)
               s = col.style_index
-              min = col.index
-              max = col.index
+              min = col.unmapped_data[:min] ? col.unmapped_data[:min] - 1 : col.index
+              max = col.unmapped_data[:max] ? col.unmapped_data[:max] - 1 : col.index
             else
               s = col[:style_index] || col[:style]
-              min = col[:index] || col[:min] || 0
-              max = col[:index] || col[:max] || col[:min] || 0
+              min = col[:min] ? col[:min] - 1 : (col[:index] || 0)
+              max = col[:max] ? col[:max] - 1 : (col[:index] || min)
             end
             next unless s
 
@@ -75,6 +78,7 @@ module Xlsxrb
 
         write_sheet_properties(sheet_properties) if sheet_properties && !sheet_properties.empty?
         write_sheet_views(freeze_pane: freeze_pane, split_pane: split_pane, selection: selection, sheet_view: sheet_view) if freeze_pane || split_pane || selection || (sheet_view && !sheet_view.empty?)
+        write_sheet_format_pr(sheet_format) if sheet_format && !sheet_format.empty?
         write_columns(columns) unless columns.empty?
 
         @builder.open_tag("sheetData")
@@ -88,7 +92,7 @@ module Xlsxrb
         row_num_str = row_num.to_s
         buf = @row_buffer ||= String.new(capacity: 65_536)
         buf << '<row r="' << row_num_str << '"'
-        buf << ' s="' << attrs[:style_index].to_s << '" customFormat="1"' if attrs[:style_index]
+        buf << ' s="' << attrs[:style_index].to_s << '" customFormat="1"' if attrs[:style_index].is_a?(Integer)
         if attrs[:height]
           buf << ' ht="' << attrs[:height].to_s << '" customHeight="1"'
         elsif attrs[:custom_height]
@@ -102,7 +106,7 @@ module Xlsxrb
         cells.each do |cell|
           if cell.is_a?(Elements::Cell)
             value = cell.value
-            style_id = cell.style_index
+            cell_style_id = cell.style_index
             col_ref = cell.ref || "#{column_letter(cell.column_index)}#{row_num_str}"
             col_idx = cell.column_index
             formula = cell.formula
@@ -110,7 +114,7 @@ module Xlsxrb
             cell_type_val = nil
           elsif cell.is_a?(Hash)
             value = cell[:value]
-            style_id = cell[:style_index]
+            cell_style_id = cell[:style_index]
             col_idx = cell[:column_index]
             col_ref = cell[:ref] || (col_idx ? "#{column_letter(col_idx)}#{row_num_str}" : nil)
             formula = cell[:formula]
@@ -118,7 +122,7 @@ module Xlsxrb
             cell_type_val = cell[:type]
           else
             value = cell
-            style_id = nil
+            cell_style_id = nil
             col_idx = nil
             col_ref = nil
             formula = nil
@@ -127,7 +131,8 @@ module Xlsxrb
           end
 
           col_style = @column_styles && col_idx ? @column_styles[col_idx] : nil
-          style_id ||= attrs[:style_index] || col_style
+          style_id = cell_style_id || attrs[:style_index] || col_style
+          style_id = nil unless style_id.is_a?(Integer)
 
           # Fast path for common unstyled cells
           if !formula && !style_id && !cell_type_val
@@ -136,7 +141,7 @@ module Xlsxrb
               buf << '<c r="' << col_ref << '"><v>' << value.to_s << "</v></c>"
               next
             when String
-              if !value.start_with?("=") && sst_index && (idx = sst_index[value])
+              if sst_index && (idx = sst_index[value])
                 buf << '<c r="' << col_ref << '" t="s"><v>' << idx.to_s << "</v></c>"
                 next
               end
@@ -157,17 +162,14 @@ module Xlsxrb
           end
 
           if value.nil? && formula.nil?
-            buf << '<c r="' << col_ref << '"'
-            buf << ' s="' << style_id.to_s << '"' if style_id
-            buf << "/>"
+            if cell_style_id.is_a?(Integer)
+              buf << '<c r="' << col_ref << '" s="' << cell_style_id.to_s << '"/>'
+            else
+              buf << '<c r="' << col_ref << '"/>'
+            end
             next
           end
 
-          if value.is_a?(String) && value.start_with?("=") && !formula
-            formula = value
-            value = nil
-          end
-
           xml_val = value
           type = cell_type_val
           formula_type = nil
@@ -181,22 +183,40 @@ module Xlsxrb
               formula_type = formula.type
               formula_ref = formula.ref
               formula_si = formula.shared_index
-              xml_val = formula.cached_value.nil? ? (value || nil) : formula.cached_value
+              xml_val = formula.cached_value.nil? ? value : formula.cached_value
             elsif formula.is_a?(Hash)
               formula_expr = formula[:formula] || formula[:expression]
               formula_ca = formula[:calculate_always]
               formula_type = formula[:type]
               formula_ref = formula[:ref]
               formula_si = formula[:si] || formula[:shared_index]
-              xml_val = formula[:value] || formula[:cached_value] || value || nil
+              xml_val = if formula.key?(:value)
+                          formula[:value]
+                        elsif formula.key?(:cached_value)
+                          formula[:cached_value]
+                        else
+                          value
+                        end
             else
               formula_expr = formula
-              xml_val = value || nil
+              xml_val = value
             end
-            formula_expr = formula_expr[1..] if formula_expr.start_with?("=")
+            formula_expr = formula_expr[1..] if formula_expr.is_a?(String) && formula_expr.start_with?("=")
           end
 
-          if !formula_expr && !type
+          if formula_expr
+            case xml_val
+            when true
+              type = "b"
+              xml_val = "1"
+            when false
+              type = "b"
+              xml_val = "0"
+            when Xlsxrb::Elements::CellError
+              type = "e"
+              xml_val = xml_val.code
+            end
+          elsif !type
             case value
             when String
               if sst_index && (idx = sst_index[value])
@@ -288,13 +308,18 @@ module Xlsxrb
             end
             f_attrs << ' ca="1"' if formula_ca
             buf << "><f#{f_attrs}>" << escape_xml(formula_expr) << "</f>"
-            if xml_val
-              buf << "<v>" << xml_val.to_s << "</v></c>"
-            else
+            if xml_val.nil?
               buf << "<v>0</v></c>"
+            else
+              v_str = xml_val.to_s
+              v_str = v_str.dup.force_encoding(Encoding::UTF_8) if v_str.encoding == Encoding::BINARY
+              v_str = escape_xml(v_str) if type == "str" || xml_val.is_a?(String)
+              buf << "<v>" << v_str << "</v></c>"
             end
           else
-            buf << "><v>" << xml_val.to_s << "</v></c>"
+            v_str = xml_val.to_s
+            v_str = v_str.dup.force_encoding(Encoding::UTF_8) if v_str.encoding == Encoding::BINARY
+            buf << "><v>" << v_str << "</v></c>"
           end
         end
 
@@ -316,7 +341,7 @@ module Xlsxrb
         buf = @row_buffer ||= String.new(capacity: 65_536)
 
         if styles.nil? && attrs.nil? && @column_styles.nil?
-          buf << "<row r=\"#{row_num_str}\">"
+          buf << '<row r="' << row_num_str << '">'
           col_index = 0
           max_len = values.length
           while col_index < max_len
@@ -329,27 +354,26 @@ module Xlsxrb
             case value
             when Integer
               val_str = value >= 0 && value < 65_536 ? INTEGER_STRINGS[value] : value.to_s
-              buf << "<c r=\"#{col_ref}#{row_num_str}\"><v>#{val_str}</v></c>"
+              buf << '<c r="' << col_ref << row_num_str << '"><v>' << val_str << "</v></c>"
             when Float
-              buf << "<c r=\"#{col_ref}#{row_num_str}\"><v>#{value}</v></c>"
+              buf << '<c r="' << col_ref << row_num_str << '"><v>' << value.to_s << "</v></c>"
             when String
-              unless value.start_with?("=")
-                raise ArgumentError, "Cell text length #{value.length} exceeds Excel limit of 32,767 characters" if @strict_excel_mode && value.length > 32_767
+              raise ArgumentError, "Cell text length #{value.length} exceeds Excel limit of 32,767 characters" if @strict_excel_mode && value.length > 32_767
 
+              if sst_index
                 idx = (sst_index[value] ||= begin
                   sst << value
                   sst.size - 1
                 end)
                 idx_str = idx < 65_536 ? INTEGER_STRINGS[idx] : idx.to_s
-                buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"s\"><v>#{idx_str}</v></c>"
-                next
+                buf << '<c r="' << col_ref << row_num_str << '" t="s"><v>' << idx_str << "</v></c>"
+              else
+                buf << '<c r="' << col_ref << row_num_str << '" t="inlineStr"><is><t>' << escape_xml(value) << "</t></is></c>"
               end
-              formula_expr = value[1..]
-              buf << "<c r=\"#{col_ref}#{row_num_str}\"><f>#{escape_xml(formula_expr)}</f><v>0</v></c>"
             when true
-              buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"b\"><v>1</v></c>"
+              buf << '<c r="' << col_ref << row_num_str << '" t="b"><v>1</v></c>'
             when false
-              buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"b\"><v>0</v></c>"
+              buf << '<c r="' << col_ref << row_num_str << '" t="b"><v>0</v></c>'
             when Date
               date_style_id = style_map ? style_map["__xlsxrb_date"] : nil
               buf << if date_style_id
@@ -380,8 +404,23 @@ module Xlsxrb
                 end
               end
               f_attrs << ' ca="1"' if value.calculate_always
-              v_val = value.cached_value.nil? ? 0 : value.cached_value
-              buf << "<c r=\"#{col_ref}#{row_num_str}\"><f#{f_attrs}>#{escape_xml(formula_expr)}</f><v>#{v_val}</v></c>"
+              c_type = ""
+              case value.cached_value
+              when true
+                c_type = ' t="b"'
+                v_val = "1"
+              when false
+                c_type = ' t="b"'
+                v_val = "0"
+              when Xlsxrb::Elements::CellError
+                c_type = ' t="e"'
+                v_val = value.cached_value.code
+              when nil
+                v_val = 0
+              else
+                v_val = value.cached_value.is_a?(String) ? escape_xml(value.cached_value) : value.cached_value
+              end
+              buf << "<c r=\"#{col_ref}#{row_num_str}\"#{c_type}><f#{f_attrs}>#{escape_xml(formula_expr)}</f><v>#{v_val}</v></c>"
             when Hash
               if value.key?(:formula)
                 formula_expr = value[:formula] || value[:expression]
@@ -399,8 +438,27 @@ module Xlsxrb
                   end
                 end
                 f_attrs << ' ca="1"' if value[:calculate_always]
-                xml_val = value[:value] || value[:cached_value] || 0
-                buf << "<c r=\"#{col_ref}#{row_num_str}\"><f#{f_attrs}>#{escape_xml(formula_expr)}</f><v>#{xml_val}</v></c>"
+                xml_val = if value.key?(:value) && !value[:value].nil?
+                            value[:value]
+                          elsif value.key?(:cached_value) && !value[:cached_value].nil?
+                            value[:cached_value]
+                          else
+                            0
+                          end
+                c_type = ""
+                case xml_val
+                when true
+                  c_type = ' t="b"'
+                  xml_val = "1"
+                when false
+                  c_type = ' t="b"'
+                  xml_val = "0"
+                when Xlsxrb::Elements::CellError
+                  c_type = ' t="e"'
+                  xml_val = xml_val.code
+                end
+                xml_val = escape_xml(xml_val) if xml_val.is_a?(String)
+                buf << "<c r=\"#{col_ref}#{row_num_str}\"#{c_type}><f#{f_attrs}>#{escape_xml(formula_expr)}</f><v>#{xml_val}</v></c>"
               end
             when Xlsxrb::Elements::CellError
               buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"e\"><v>#{value.code}</v></c>"
@@ -425,12 +483,19 @@ module Xlsxrb
         end
 
         is_styles_collection = styles && (styles.is_a?(Array) || styles.is_a?(Hash))
-        single_style_id = nil
-        single_style_id = style_map[styles] if styles && style_map && !is_styles_collection
+        single_style_id = resolve_style_id(styles, style_map) unless is_styles_collection
+
+        row_style = attrs ? attrs[:style_index] : nil
+        row_style_id = resolve_style_id(row_style, style_map)
 
         buf << '<row r="' << row_num_str << '"'
+        buf << ' s="' << row_style_id.to_s << '" customFormat="1"' if row_style_id.is_a?(Integer)
         if attrs
-          buf << ' ht="' << attrs[:height].to_s << '" customHeight="1"' if attrs[:height]
+          if attrs[:height]
+            buf << ' ht="' << attrs[:height].to_s << '" customHeight="1"'
+          elsif attrs[:custom_height]
+            buf << ' customHeight="1"'
+          end
           buf << ' hidden="1"' if attrs[:hidden]
           buf << ' collapsed="1"' if attrs[:collapsed]
           buf << ' outlineLevel="' << attrs[:outline_level].to_s << '"' if attrs[:outline_level]
@@ -443,40 +508,31 @@ module Xlsxrb
           max_len = [max_len, styles_len].max
         end
 
-        row_style = attrs ? attrs[:style_index] : nil
-        row_style_id = row_style && style_map ? (style_map[row_style] || style_map[row_style.to_s] || row_style) : row_style
-
         col_index = 0
         while col_index < max_len
           value = col_index < values.length ? values[col_index] : nil
-          style_id = single_style_id
+          cell_style_id = single_style_id
           if is_styles_collection
             style_name = if styles.is_a?(Array)
                            col_index < styles.length ? styles[col_index] : nil
                          else
                            styles[col_index]
                          end
-            style_id = if style_map && style_name
-                         style_map[style_name] || style_map[style_name.to_s] || style_name
-                       else
-                         style_name
-                       end
+            cell_style_id = resolve_style_id(style_name, style_map)
           end
 
-          if style_id.nil?
+          if cell_style_id.nil?
             col_style = @column_styles ? @column_styles[col_index] : nil
-            col_style_id = if col_style && style_map
-                             style_map[col_style] || style_map[col_style.to_s] || col_style
-                           else
-                             col_style
-                           end
+            col_style_id = resolve_style_id(col_style, style_map)
             style_id = row_style_id || col_style_id
+          else
+            style_id = cell_style_id
           end
 
           col_ref = COLUMN_LETTERS[col_index] || column_letter(col_index)
 
           if value.nil?
-            buf << '<c r="' << col_ref << row_num_str << '" s="' << style_id.to_s << '"/>' if style_id
+            buf << '<c r="' << col_ref << row_num_str << '" s="' << cell_style_id.to_s << '"/>' if cell_style_id
             col_index += 1
             next
           end
@@ -494,7 +550,7 @@ module Xlsxrb
               col_index += 1
               next
             when String
-              unless value.start_with?("=")
+              if sst_index
                 idx = sst_index[value]
                 unless idx
                   sst << value
@@ -503,9 +559,11 @@ module Xlsxrb
                 end
                 idx_str = INTEGER_STRINGS[idx] || idx.to_s
                 buf << '<c r="' << col_ref << row_num_str << '" t="s"><v>' << idx_str << "</v></c>"
-                col_index += 1
-                next
+              else
+                buf << '<c r="' << col_ref << row_num_str << '" t="inlineStr"><is><t>' << escape_xml(value) << "</t></is></c>"
               end
+              col_index += 1
+              next
             when true
               buf << '<c r="' << col_ref << row_num_str << '" t="b"><v>1</v></c>'
               col_index += 1
@@ -551,6 +609,9 @@ module Xlsxrb
             when false
               type = "b"
               xml_val = "0"
+            when Xlsxrb::Elements::CellError
+              type = "e"
+              xml_val = value.cached_value.code
             end
           when Hash
             if value.key?(:formula)
@@ -559,7 +620,11 @@ module Xlsxrb
               formula_type = value[:type]
               formula_ref = value[:ref]
               formula_si = value[:si] || value[:shared_index]
-              xml_val = value[:value] || value[:cached_value]
+              xml_val = if value.key?(:value)
+                          value[:value]
+                        elsif value.key?(:cached_value)
+                          value[:cached_value]
+                        end
               case xml_val
               when String
                 type = "str"
@@ -569,26 +634,12 @@ module Xlsxrb
               when false
                 type = "b"
                 xml_val = "0"
+              when Xlsxrb::Elements::CellError
+                type = "e"
+                xml_val = xml_val.code
               end
             end
-          when String
-            if value.start_with?("=") && value.length > 1
-              formula_expr = value
-              xml_val = nil
-            elsif sst_index
-              idx = sst_index[value]
-              unless idx
-                sst << value
-                idx = sst.size - 1
-                sst_index[value] = idx
-              end
-              xml_val = idx
-              type = "s"
-            else
-              xml_val = value
-              type = "inlineStr"
-            end
-          when Xlsxrb::Elements::RichText
+          when String, Xlsxrb::Elements::RichText
             if sst_index
               idx = sst_index[value]
               unless idx
@@ -638,11 +689,13 @@ module Xlsxrb
               end
             end
             f_attrs << ' ca="1"' if formula_ca
-            buf << "<f#{f_attrs}>" << escape_xml(formula_expr) << "</f>"
-            if xml_val
-              buf << "<v>" << xml_val.to_s << "</v></c>"
-            else
+            buf << "><f#{f_attrs}>" << escape_xml(formula_expr) << "</f>"
+            if xml_val.nil?
               buf << "<v>0</v></c>"
+            else
+              v_str = xml_val.to_s
+              v_str = escape_xml(v_str) if type == "str" || xml_val.is_a?(String)
+              buf << "<v>" << v_str << "</v></c>"
             end
           elsif type == "inlineStr"
             buf << "><is><t>" << escape_xml(xml_val.to_s) << "</t></is></c>"
@@ -662,12 +715,12 @@ module Xlsxrb
 
       # Write the worksheet footer. Call once after all rows.
       # Options for post-sheetData elements (in OOXML order):
-      def finish(drawing_rid: nil, sheet_protection: nil, auto_filter: nil,
+      def finish(drawing_rid: nil, sheet_protection: nil, protected_ranges: nil, auto_filter: nil,
                  filter_columns: nil, sort_state: nil, merge_cells: nil,
                  conditional_formats: nil, data_validations: nil,
                  hyperlinks: nil, print_options: nil, page_margins: nil,
                  page_setup: nil, header_footer: nil, row_breaks: nil,
-                 col_breaks: nil, tables: nil, table_start_rid: nil,
+                 col_breaks: nil, cell_watches: nil, tables: nil, table_start_rid: nil,
                  legacy_drawing_rid: nil, sparkline_groups: nil)
         return if @finished
 
@@ -681,6 +734,7 @@ module Xlsxrb
 
         # Elements must appear in OOXML specification order after sheetData
         write_sheet_protection(sheet_protection) if sheet_protection
+        write_protected_ranges(protected_ranges) if protected_ranges && !protected_ranges.empty?
         write_auto_filter(auto_filter, filter_columns, sort_state) if auto_filter
         write_merge_cells(merge_cells) if merge_cells && !merge_cells.empty?
         write_conditional_formatting(conditional_formats) if conditional_formats && !conditional_formats.empty?
@@ -692,6 +746,7 @@ module Xlsxrb
         write_header_footer(header_footer) if header_footer && !header_footer.empty?
         write_row_breaks(row_breaks) if row_breaks && !row_breaks.empty?
         write_col_breaks(col_breaks) if col_breaks && !col_breaks.empty?
+        write_cell_watches(cell_watches) if cell_watches && !cell_watches.empty?
         @builder.empty_tag("drawing", { "r:id": drawing_rid }) if drawing_rid
         @builder.empty_tag("legacyDrawing", { "r:id": legacy_drawing_rid }) if legacy_drawing_rid
         write_table_parts(tables, table_start_rid) if tables && !tables.empty?
@@ -701,6 +756,17 @@ module Xlsxrb
 
       private
 
+      def resolve_style_id(style, style_map)
+        return nil if style.nil?
+
+        if style_map
+          mapped = style_map[style] || style_map[style.to_s]
+          return mapped if mapped
+        end
+
+        style.is_a?(Integer) ? style : nil
+      end
+
       # --- Pre-sheetData elements ---
 
       def write_sheet_properties(props)
@@ -727,12 +793,26 @@ module Xlsxrb
 
       def write_sheet_views(freeze_pane: nil, split_pane: nil, selection: nil, sheet_view: nil)
         @builder.open_tag("sheetViews")
-        sv_attrs = { tabSelected: "1", workbookViewId: "0" }
+        sv_attrs = { workbookViewId: "0" }
         if sheet_view
-          sv_attrs[:showGridLines] = "0" if sheet_view[:show_grid_lines] == false
-          sv_attrs[:showRowColHeaders] = "0" if sheet_view[:show_row_col_headers] == false
-          sv_attrs[:rightToLeft] = "1" if sheet_view[:right_to_left]
+          sv_attrs[:windowProtection] = sheet_view[:window_protection] ? "1" : "0" unless sheet_view[:window_protection].nil?
+          sv_attrs[:showFormulas] = sheet_view[:show_formulas] ? "1" : "0" unless sheet_view[:show_formulas].nil?
+          sv_attrs[:showGridLines] = sheet_view[:show_grid_lines] ? "1" : "0" unless sheet_view[:show_grid_lines].nil?
+          sv_attrs[:showRowColHeaders] = sheet_view[:show_row_col_headers] ? "1" : "0" unless sheet_view[:show_row_col_headers].nil?
+          sv_attrs[:showZeros] = sheet_view[:show_zeros] ? "1" : "0" unless sheet_view[:show_zeros].nil?
+          sv_attrs[:rightToLeft] = sheet_view[:right_to_left] ? "1" : "0" unless sheet_view[:right_to_left].nil?
+          sv_attrs[:tabSelected] = "1" if sheet_view[:tab_selected]
+          sv_attrs[:showRuler] = sheet_view[:show_ruler] ? "1" : "0" unless sheet_view[:show_ruler].nil?
+          sv_attrs[:showOutlineSymbols] = sheet_view[:show_outline_symbols] ? "1" : "0" unless sheet_view[:show_outline_symbols].nil?
+          sv_attrs[:defaultGridColor] = sheet_view[:default_grid_color] ? "1" : "0" unless sheet_view[:default_grid_color].nil?
+          sv_attrs[:showWhiteSpace] = sheet_view[:show_white_space] ? "1" : "0" unless sheet_view[:show_white_space].nil?
+          sv_attrs[:view] = sheet_view[:view].to_s if sheet_view[:view]
+          sv_attrs[:topLeftCell] = sheet_view[:top_left_cell].to_s if sheet_view[:top_left_cell]
+          sv_attrs[:colorId] = sheet_view[:color_id].to_s if sheet_view[:color_id]
           sv_attrs[:zoomScale] = sheet_view[:zoom_scale].to_s if sheet_view[:zoom_scale]
+          sv_attrs[:zoomScaleNormal] = sheet_view[:zoom_scale_normal].to_s if sheet_view[:zoom_scale_normal]
+          sv_attrs[:zoomScaleSheetLayoutView] = sheet_view[:zoom_scale_sheet_layout_view].to_s if sheet_view[:zoom_scale_sheet_layout_view]
+          sv_attrs[:zoomScalePageLayoutView] = sheet_view[:zoom_scale_page_layout_view].to_s if sheet_view[:zoom_scale_page_layout_view]
         end
         @builder.open_tag("sheetView", sv_attrs)
         if freeze_pane
@@ -741,35 +821,59 @@ module Xlsxrb
           pane_attrs[:ySplit] = freeze_pane[:row].to_s if freeze_pane[:row]&.positive?
           top_left_col = column_letter(freeze_pane[:col] || 0)
           top_left_row = (freeze_pane[:row] || 0) + 1
-          pane_attrs[:topLeftCell] = "#{top_left_col}#{top_left_row}"
+          pane_attrs[:topLeftCell] = freeze_pane[:top_left_cell] || "#{top_left_col}#{top_left_row}"
           pane_attrs[:state] = "frozen"
           # Determine active pane
-          pane_attrs[:activePane] = if (freeze_pane[:col] || 0).positive? && (freeze_pane[:row] || 0).positive?
-                                      "bottomRight"
-                                    elsif (freeze_pane[:col] || 0).positive?
-                                      "topRight"
-                                    else
-                                      "bottomLeft"
-                                    end
+          pane_attrs[:activePane] = freeze_pane[:active_pane] || if (freeze_pane[:col] || 0).positive? && (freeze_pane[:row] || 0).positive?
+                                                                   "bottomRight"
+                                                                 elsif (freeze_pane[:col] || 0).positive?
+                                                                   "topRight"
+                                                                 else
+                                                                   "bottomLeft"
+                                                                 end
           @builder.empty_tag("pane", pane_attrs)
         elsif split_pane
           pane_attrs = {}
           pane_attrs[:xSplit] = split_pane[:x_split].to_s if split_pane[:x_split]&.positive?
           pane_attrs[:ySplit] = split_pane[:y_split].to_s if split_pane[:y_split]&.positive?
           pane_attrs[:topLeftCell] = split_pane[:top_left_cell] if split_pane[:top_left_cell]
+          pane_attrs[:activePane] = split_pane[:active_pane] if split_pane[:active_pane]
+          pane_attrs[:state] = split_pane[:state].to_s if split_pane[:state]
           @builder.empty_tag("pane", pane_attrs)
         end
-        if selection
-          sel_attrs = {}
-          sel_attrs[:activeCell] = selection[:active_cell] if selection[:active_cell]
-          sel_attrs[:sqref] = selection[:sqref] || selection[:active_cell] if selection[:active_cell]
-          sel_attrs[:pane] = selection[:pane] if selection[:pane]
-          @builder.empty_tag("selection", sel_attrs)
+        active_selection = selection || (sheet_view[:selection] if sheet_view)
+        if active_selection
+          selections = active_selection.is_a?(Array) ? active_selection : [active_selection]
+          selections.each do |sel|
+            sel_attrs = {}
+            sel_attrs[:pane] = sel[:pane].to_s if sel[:pane]
+            sel_attrs[:activeCell] = sel[:active_cell].to_s if sel[:active_cell]
+            sel_attrs[:activeCellId] = sel[:active_cell_id].to_s if sel[:active_cell_id]
+            sqref = sel[:sqref] || sel[:active_cell]
+            sel_attrs[:sqref] = sqref.to_s if sqref
+            @builder.empty_tag("selection", sel_attrs) unless sel_attrs.empty?
+          end
         end
         @builder.close_tag("sheetView")
         @builder.close_tag("sheetViews")
       end
 
+      def write_sheet_format_pr(fmt)
+        return if fmt.nil? || fmt.empty?
+
+        attrs = {}
+        attrs[:defaultRowHeight] = fmt[:default_row_height].to_s if fmt[:default_row_height]
+        attrs[:defaultColWidth] = fmt[:default_col_width].to_s if fmt[:default_col_width]
+        attrs[:baseColWidth] = fmt[:base_col_width].to_s if fmt[:base_col_width]
+        attrs[:outlineLevelRow] = fmt[:outline_level_row].to_s if fmt[:outline_level_row]
+        attrs[:outlineLevelCol] = fmt[:outline_level_col].to_s if fmt[:outline_level_col]
+        attrs[:customHeight] = "1" if fmt[:custom_height]
+        attrs[:zeroHeight] = "1" if fmt[:zero_height]
+        attrs[:thickTop] = "1" if fmt[:thick_top]
+        attrs[:thickBottom] = "1" if fmt[:thick_bottom]
+        @builder.empty_tag("sheetFormatPr", attrs) unless attrs.empty?
+      end
+
       # --- Post-sheetData elements (in OOXML order) ---
 
       def write_sheet_protection(opts)
@@ -798,6 +902,28 @@ module Xlsxrb
         @builder.empty_tag("sheetProtection", attrs)
       end
 
+      def write_protected_ranges(ranges)
+        @builder.open_tag("protectedRanges")
+        ranges.each do |pr|
+          attrs = { sqref: pr[:sqref].to_s, name: pr[:name].to_s }
+          attrs[:password] = pr[:password].to_s if pr[:password]
+          attrs[:algorithmName] = pr[:algorithm_name].to_s if pr[:algorithm_name]
+          attrs[:hashValue] = pr[:hash_value].to_s if pr[:hash_value]
+          attrs[:saltValue] = pr[:salt_value].to_s if pr[:salt_value]
+          attrs[:spinCount] = pr[:spin_count].to_s if pr[:spin_count]
+          attrs[:securityDescriptor] = pr[:security_descriptor].to_s if pr[:security_descriptor]
+          sds = pr[:security_descriptors] || []
+          if sds.empty?
+            @builder.empty_tag("protectedRange", attrs)
+          else
+            @builder.open_tag("protectedRange", attrs)
+            sds.each { |sd| @builder.tag("securityDescriptor") { @builder.text(sd.to_s) } }
+            @builder.close_tag("protectedRange")
+          end
+        end
+        @builder.close_tag("protectedRanges")
+      end
+
       def write_auto_filter(range, filter_columns, sort_state)
         if (filter_columns && !filter_columns.empty?) || sort_state
           @builder.open_tag("autoFilter", { ref: range })
@@ -1026,6 +1152,9 @@ module Xlsxrb
       end
 
       def write_data_validations(validations)
+        validations = validations.reject { |dv| dv[:sqref].nil? || dv[:sqref].to_s.empty? }
+        return if validations.empty?
+
         @builder.open_tag("dataValidations", { count: validations.size.to_s })
         validations.each do |dv|
           if dv[:in].is_a?(Array)
@@ -1045,6 +1174,8 @@ module Xlsxrb
           dv_attrs[:error] = dv[:error] if dv[:error]
           dv_attrs[:promptTitle] = dv[:prompt_title] if dv[:prompt_title]
           dv_attrs[:prompt] = dv[:prompt] if dv[:prompt]
+          dv_attrs[:showDropDown] = "1" if dv[:show_drop_down]
+          dv_attrs[:imeMode] = dv[:ime_mode].to_s if dv[:ime_mode]
 
           has_formulas = dv[:formula1] || dv[:formula2]
           if has_formulas
@@ -1101,7 +1232,7 @@ module Xlsxrb
         attrs[:scale] = opts[:scale].to_s if opts[:scale]
         attrs[:fitToWidth] = opts[:fit_to_width].to_s if opts[:fit_to_width]
         attrs[:fitToHeight] = opts[:fit_to_height].to_s if opts[:fit_to_height]
-        attrs[:firstPageNumber] = opts[:first_page_number].to_s if opts[:first_page_number]
+        attrs[:firstPageNumber] = opts[:first_page_number].to_s if opts[:first_page_number] && opts[:first_page_number].to_i >= 0
         attrs[:pageOrder] = opts[:page_order].to_s if opts[:page_order]
         attrs[:blackAndWhite] = "1" if opts[:black_and_white]
         attrs[:draft] = "1" if opts[:draft]
@@ -1120,7 +1251,14 @@ module Xlsxrb
       def write_row_breaks(breaks)
         @builder.open_tag("rowBreaks", { count: breaks.size.to_s, manualBreakCount: breaks.size.to_s })
         breaks.each do |brk|
-          @builder.empty_tag("brk", { id: brk.to_s, max: "16383", man: "1" })
+          attrs = if brk.is_a?(Hash)
+                    a = { id: (brk[:id] || brk[:row] || 0).to_s, max: (brk[:max] || 16_383).to_s, man: brk.fetch(:man, true) ? "1" : "0" }
+                    a[:min] = brk[:min].to_s if brk[:min]
+                    a
+                  else
+                    { id: brk.to_s, max: "16383", man: "1" }
+                  end
+          @builder.empty_tag("brk", attrs)
         end
         @builder.close_tag("rowBreaks")
       end
@@ -1128,11 +1266,26 @@ module Xlsxrb
       def write_col_breaks(breaks)
         @builder.open_tag("colBreaks", { count: breaks.size.to_s, manualBreakCount: breaks.size.to_s })
         breaks.each do |brk|
-          @builder.empty_tag("brk", { id: brk.to_s, max: "1048575", man: "1" })
+          attrs = if brk.is_a?(Hash)
+                    a = { id: (brk[:id] || brk[:col] || 0).to_s, max: (brk[:max] || 1_048_575).to_s, man: brk.fetch(:man, true) ? "1" : "0" }
+                    a[:min] = brk[:min].to_s if brk[:min]
+                    a
+                  else
+                    { id: brk.to_s, max: "1048575", man: "1" }
+                  end
+          @builder.empty_tag("brk", attrs)
         end
         @builder.close_tag("colBreaks")
       end
 
+      def write_cell_watches(watches)
+        @builder.open_tag("cellWatches")
+        watches.each do |w|
+          @builder.empty_tag("cellWatch", { r: w.to_s })
+        end
+        @builder.close_tag("cellWatches")
+      end
+
       def write_table_parts(tables, start_rid)
         @builder.open_tag("tableParts", { count: tables.size.to_s })
         tables.each_with_index do |_tbl, idx|
@@ -1216,16 +1369,32 @@ module Xlsxrb
       def write_columns(columns)
         @builder.open_tag("cols")
         columns.each do |col|
+          if col.is_a?(Elements::Column)
+            min = col.unmapped_data[:min] || (col.index + 1)
+            max = col.unmapped_data[:max] || (col.index + 1)
+            width = col.width
+            hidden = col.hidden
+            custom_width = col.custom_width || col.width
+            outline_level = col.outline_level
+            style_id = col.style_index
+          else
+            min = col[:min] || ((col[:index] || 0) + 1)
+            max = col[:max] || ((col[:index] || 0) + 1)
+            width = col[:width]
+            hidden = col[:hidden]
+            custom_width = col[:custom_width] || col[:width]
+            outline_level = col[:outline_level]
+            style_id = col[:style_index] || col[:style]
+          end
           attrs = {
-            min: ((col[:index] || col[:min] || 0) + 1).to_s,
-            max: ((col[:index] || col[:max] || col[:min] || 0) + 1).to_s
+            min: min.to_s,
+            max: max.to_s
           }
-          attrs[:width] = col[:width].to_s if col[:width]
-          attrs[:hidden] = "1" if col[:hidden]
-          attrs[:customWidth] = "1" if col[:custom_width] || col[:width]
-          attrs[:outlineLevel] = col[:outline_level].to_s if col[:outline_level]
-          style_id = col[:style_index] || col[:style]
-          attrs[:style] = style_id.to_s if style_id
+          attrs[:width] = width.to_s if width
+          attrs[:hidden] = "1" if hidden
+          attrs[:customWidth] = "1" if custom_width
+          attrs[:outlineLevel] = outline_level.to_s if outline_level
+          attrs[:style] = style_id.to_s if style_id.is_a?(Integer)
           @builder.empty_tag("col", attrs)
         end
         @builder.close_tag("cols")
@@ -1237,15 +1406,27 @@ module Xlsxrb
 
         value = cell[:value]
         formula = cell[:formula]
-        # For formula cells with cached values, don't infer type from value
-        type = formula ? cell[:type] : (cell[:type] || cell_type(value))
+        # For formula cells with cached values, infer type for booleans and strings
+        type = cell[:type] || if formula
+                                case value
+                                when true, false then "b"
+                                end
+                              else
+                                cell_type(value)
+                              end
         attrs[:t] = type if type
         col_idx = cell[:column_index]
         col_style = @column_styles && col_idx ? @column_styles[col_idx] : nil
-        style_id = cell[:style_index] || col_style
-        attrs[:s] = style_id.to_s if style_id
+        cell_style_id = cell[:style_index]
+        style_id = cell_style_id || col_style
+        attrs[:s] = style_id.to_s if style_id.is_a?(Integer)
 
         if value.nil? && formula.nil?
+          if cell_style_id.is_a?(Integer)
+            attrs[:s] = cell_style_id.to_s
+          else
+            attrs.delete(:s)
+          end
           @builder.empty_tag("c", attrs)
           return
         end
@@ -1317,6 +1498,7 @@ module Xlsxrb
 
       def escape_xml(value)
         str = value.to_s
+        str = str.dup.force_encoding(Encoding::UTF_8) if str.encoding == Encoding::BINARY
         str = str.gsub(INVALID_XML_CHARS_RE, "") if str.match?(INVALID_XML_CHARS_RE)
         str.match?(ESCAPE_RE) ? str.gsub(ESCAPE_RE, ESCAPE_MAP) : str
       end