write_xlsx 0.0.2 → 0.0.3

data/lib/write_xlsx/worksheet.rb

@@ -102,6 +102,156 @@ module Writexlsx
   class Worksheet
     include Writexlsx::Utility
 
+    class CellData   # :nodoc:
+      include Writexlsx::Utility
+
+      attr_reader :row, :col, :token, :xf
+      attr_reader :result, :range, :link_type, :url, :tip
+
+      #
+      # Write the <cell> element. This is the innermost loop so efficiency is
+      # important where possible.
+      #
+      def write_cell(worksheet) #:nodoc:
+        xf_index = 0
+        xf_index = xf.get_xf_index if xf.respond_to?(:get_xf_index)
+
+        attributes = ['r', xl_rowcol_to_cell(row, col)]
+
+        # Add the cell format index.
+        if xf_index != 0
+          attributes << 's' << xf_index
+        elsif worksheet.set_rows[row] && worksheet.set_rows[row][1]
+          row_xf = worksheet.set_rows[row][1]
+          attributes << 's' << row_xf.get_xf_index
+        elsif worksheet.col_formats[col]
+          col_xf = worksheet.col_formats[col]
+          attributes << 's' << col_xf.get_xf_index
+        end
+        attributes
+      end
+    end
+
+    class NumberCellData < CellData # :nodoc:
+      def initialize(row, col, num, xf)
+        @row, @col, @token, @xf = row, col, num, xf
+      end
+
+      def data
+        @token
+      end
+
+      def write_cell(worksheet)
+        attributes = super(worksheet)
+        worksheet.writer.start_tag('c', attributes)
+        worksheet.write_cell_value(token)
+        worksheet.writer.end_tag('c')
+      end
+    end
+
+    class StringCellData < CellData # :nodoc:
+      def initialize(row, col, index, xf)
+        @row, @col, @token, @xf = row, col, index, xf
+      end
+
+      def data
+        { :sst_id => token }
+      end
+
+      def write_cell(worksheet)
+        attributes = super(worksheet)
+        attributes << 't' << 's'
+        worksheet.writer.start_tag('c', attributes)
+        worksheet.write_cell_value(token)
+        worksheet.writer.end_tag('c')
+      end
+    end
+
+    class FormulaCellData < CellData # :nodoc:
+      def initialize(row, col, formula, xf, result)
+        @row, @col, @token, @xf, @result = row, col, formula, xf, result
+      end
+
+      def data
+        @result || 0
+      end
+
+      def write_cell(worksheet)
+        attributes = super(worksheet)
+        worksheet.writer.start_tag('c', attributes)
+        worksheet.write_cell_formula(token)
+        worksheet.write_cell_value(result || 0)
+        worksheet.writer.end_tag('c')
+      end
+    end
+
+    class FormulaArrayCellData < CellData # :nodoc:
+      def initialize(row, col, formula, xf, range, result)
+        @row, @col, @token, @xf, @range, @result = row, col, formula, xf, range, result
+      end
+
+      def data
+        @result || 0
+      end
+
+      def write_cell(worksheet)
+        attributes = super(worksheet)
+        worksheet.writer.start_tag('c', attributes)
+        worksheet.write_cell_array_formula(token, range)
+        worksheet.write_cell_value(result)
+        worksheet.writer.end_tag('c')
+      end
+    end
+
+    class HyperlinkCellData < CellData # :nodoc:
+      def initialize(row, col, index, xf, link_type, url, str, tip)
+        @row, @col, @token, @xf, @link_type, @url, @str, @tip =
+          row, col, index, xf, link_type, url, str, tip
+      end
+
+      def data
+        { :sst_id => token }
+      end
+
+      def write_cell(worksheet)
+        attributes = super(worksheet)
+        attributes << 't' << 's'
+        worksheet.writer.start_tag('c', attributes)
+        worksheet.write_cell_value(token)
+        worksheet.writer.end_tag('c')
+
+        if link_type == 1
+          # External link with rel file relationship.
+          worksheet.hlink_count += 1
+          worksheet.hlink_refs <<
+            [
+             link_type,    row,     col,
+             worksheet.hlink_count, @str, @tip
+            ]
+
+          worksheet.external_hyper_links << [ '/hyperlink', @url, 'External' ]
+        elsif link_type
+          # External link with rel file relationship.
+          worksheet.hlink_refs << [link_type, row, col, @url, @str, @tip ]
+        end
+      end
+    end
+
+    class BlankCellData < CellData # :nodoc:
+      def initialize(row, col, index, xf)
+        @row, @col, @xf = row, col, xf
+      end
+
+      def data
+        ''
+      end
+
+      def write_cell(worksheet)
+        attributes = super(worksheet)
+        worksheet.writer.empty_tag('c', attributes)
+      end
+    end
+
     class PrintStyle # :nodoc:
       attr_accessor :margin_left, :margin_right, :margin_top, :margin_bottom  # :nodoc:
       attr_accessor :margin_header, :margin_footer                            # :nodoc:
@@ -109,6 +259,7 @@ module Writexlsx
       attr_accessor :hbreaks, :vbreaks, :scale                                # :nodoc:
       attr_accessor :fit_page, :fit_width, :fit_height, :page_setup_changed   # :nodoc:
       attr_accessor :across                                                   # :nodoc:
+      attr_writer   :orientation
 
       def initialize # :nodoc:
         @margin_left = 0.7
@@ -128,6 +279,7 @@ module Writexlsx
         @fit_height = nil
         @page_setup_changed = false
         @across = false
+        @orientation = true
       end
 
       def attributes    # :nodoc:
@@ -140,18 +292,20 @@ module Writexlsx
          'footer', @margin_footer
         ]
       end
-    end
 
-    RowMax   = 1048576  # :nodoc:
-    ColMax   = 16384    # :nodoc:
-    StrMax   = 32767    # :nodoc:
-    Buffer   = 4096     # :nodoc:
+      def orientation?
+        !!@orientation
+      end
+    end
 
-    attr_reader :index 
-    attr_reader :charts, :images, :drawing
-    attr_reader :external_hyper_links, :external_drawing_links, :external_comment_links, :drawing_links
-    attr_reader :vml_data_id, :vml_shape_id, :comments_array
-    attr_reader :autofilter_area, :hidden
+    attr_reader :index # :nodoc:
+    attr_reader :charts, :images, :drawing # :nodoc:
+    attr_reader :external_hyper_links, :external_drawing_links # :nodoc:
+    attr_reader :external_comment_links, :drawing_links # :nodoc:
+    attr_reader :vml_data_id # :nodoc:
+    attr_reader :autofilter_area # :nodoc:
+    attr_reader :writer, :set_rows, :col_formats # :nodoc:
+    attr_accessor :vml_shape_id, :hlink_count, :hlink_refs # :nodoc:
 
     def initialize(workbook, index, name) #:nodoc:
       @writer = Package::XMLWriterSimple.new
@@ -160,18 +314,15 @@ module Writexlsx
       @index = index
       @name = name
       @colinfo = []
-      @table = []
+      @cell_data_table = {}
       @filter_on = false
 
       @print_style = PrintStyle.new
-      
+
       @print_area    = ''
 
       @screen_gridlines = true
       @show_zeros = true
-      @xls_rowmax = RowMax
-      @xls_colmax = ColMax
-      @xls_strmax = StrMax
       @dim_rowmin = nil
       @dim_rowmax = nil
       @dim_colmin = nil
@@ -181,8 +332,6 @@ module Writexlsx
 
       @tab_color  = 0
 
-      @orientation = true
-
       @set_cols = {}
       @set_rows = {}
       @zoom = 100
@@ -214,8 +363,7 @@ module Writexlsx
 
       @merge = []
 
-      @has_comments = false
-      @comments = {}
+      @comments = Package::Comments.new(self)
 
       @validations = []
 
@@ -476,7 +624,7 @@ module Writexlsx
     # and last_col are optional.
     #
     # If set_column() is applied to a single column the value of first_col
-    # and last_col should be the same. In the case where $last_col is zero
+    # and last_col should be the same. In the case where last_col is zero
     # it is set to the same value as first_col.
     #
     # It is also possible, and generally clearer, to specify a column range
@@ -614,7 +762,7 @@ module Writexlsx
     #
     # This method can be used to specify which cell or cells are selected
     # in a worksheet. The most common requirement is to select a single cell,
-    # in which case $last_row and $last_col can be omitted. The active cell
+    # in which case last_row and last_col can be omitted. The active cell
     # within a selected range is determined by the order in which first and
     # last are specified. It is also possible to specify a cell or a range
     # using A1 notation. See the note about "Cell notation".
@@ -666,7 +814,7 @@ module Writexlsx
     # that the splitter bars are not visible. This is the same as the
     # Window->Freeze Panes menu command in Excel
     #
-    # The parameters $row and $col are used to specify the location of
+    # The parameters row and col are used to specify the location of
     # the split. It should be noted that the split is specified at the
     # top or left of a cell and that the method uses zero based indexing.
     # Therefore to freeze the first row of a worksheet it is necessary
@@ -674,7 +822,7 @@ module Writexlsx
     # This might lead you to think that you are using a 1 based index
     # but this is not the case.
     #
-    # You can set one of the $row and $col parameters as zero if you
+    # You can set one of the row and col parameters as zero if you
     # do not want either a vertical or horizontal split.
     #
     # Examples:
@@ -686,16 +834,16 @@ module Writexlsx
     #     worksheet.freeze_panes(1, 2)    # Freeze first row and first 2 columns
     #     worksheet.freeze_panes('C2')    # Same using A1 notation
     #
-    # The parameters $top_row and $left_col are optional. They are used
+    # The parameters top_row and left_col are optional. They are used
     # to specify the top-most or left-most visible row or column in the
     # scrolling region of the panes. For example to freeze the first row
     # and to have the scrolling region begin at row twenty:
     #
     #     worksheet.freeze_panes(1, 0, 20, 0)
     #
-    # You cannot use A1 notation for the $top_row and $left_col parameters.
+    # You cannot use A1 notation for the top_row and left_col parameters.
     #
-    # See also the panes.pl program in the examples directory of the
+    # See also the panes.rb program in the examples directory of the
     # distribution.
     #
     def freeze_panes(*args)
@@ -722,7 +870,7 @@ module Writexlsx
     # file format and isn't sufficient to describe all cases of split panes.
     # It should probably be something like:
     #
-    #     split_panes($y, $x, $top_row, $left_col, $offset_row, $offset_col)
+    #     split_panes(y, x, top_row, left_col, offset_row, offset_col)
     #
     # I'll look at changing this if it becomes an issue.
     #++
@@ -731,15 +879,15 @@ module Writexlsx
     # method in that the splits between the panes will be visible to the user
     # and each pane will have its own scroll bars.
     #
-    # The parameters $y and $x are used to specify the vertical and horizontal
-    # position of the split. The units for $y and $x are the same as those
+    # The parameters y and x are used to specify the vertical and horizontal
+    # position of the split. The units for y and x are the same as those
     # used by Excel to specify row height and column width. However, the
     # vertical and horizontal units are different from each other. Therefore
-    # you must specify the $y and $x parameters in terms of the row heights
+    # you must specify the y and x parameters in terms of the row heights
     # and column widths that you have set or the default values which are 15
     # for a row and 8.43 for a column.
     #
-    # You can set one of the $y and $x parameters as zero if you do not want
+    # You can set one of the y and x parameters as zero if you do not want
     # either a vertical or horizontal split. The parameters top_row and left_col
     # are optional. They are used to specify the top-most or left-most visible
     # row or column in the bottom-right pane.
@@ -766,7 +914,7 @@ module Writexlsx
     # need to call this method.
     #
     def set_portrait
-      @orientation        = true
+      @print_style.orientation        = true
       @print_style.page_setup_changed = true
     end
 
@@ -774,7 +922,7 @@ module Writexlsx
     # Set the page orientation as landscape.
     #
     def set_landscape
-      @orientation         = false
+      @print_style.orientation         = false
       @print_style.page_setup_changed  = true
     end
 
@@ -796,7 +944,7 @@ module Writexlsx
     #     worksheet1.set_tab_color('red')
     #     worksheet2.set_tab_color(0x0C)
     #
-    # See the tab_colors.pl program in the examples directory of the distro.
+    # See the tab_colors.rb program in the examples directory of the distro.
     #
     def set_tab_color(color)
       @tab_color = Colors.new.get_color(color)
@@ -1285,10 +1433,6 @@ module Writexlsx
       @print_style.repeat_cols
     end
 
-    def print_area # :nodoc:
-      @print_area.dup
-    end
-
     #
     # :call-seq:
     #   print_area(first_row, first_col, last_row, last_col)
@@ -1297,22 +1441,23 @@ module Writexlsx
     # be printed. All four parameters must be specified. You can also use
     # A1 notation, see the note about "Cell notation".
     #
-    #     $worksheet1->print_area( 'A1:H20' );    # Cells A1 to H20
-    #     $worksheet2->print_area( 0, 0, 19, 7 ); # The same
-    #     $worksheet2->print_area( 'A:H' );       # Columns A to H if rows have data
+    #     worksheet1.print_area( 'A1:H20' );    # Cells A1 to H20
+    #     worksheet2.print_area( 0, 0, 19, 7 ); # The same
+    #     worksheet2.print_area( 'A:H' );       # Columns A to H if rows have data
     #
     def print_area(*args)
-      return @print_area if args.empty?
+      return @print_area.dup if args.empty?
       row1, col1, row2, col2 = row_col_notation(args)
       return if [row1, col1, row2, col2].include?(nil)
 
       # Ignore max print area since this is the same as no print area for Excel.
-      if row1 == 0 && col1 == 0 && row2 == @xls_rowmax - 1 && col2 == @xls_colmax - 1
+      if row1 == 0 && col1 == 0 && row2 == ROW_MAX - 1 && col2 == COL_MAX - 1
         return
       end
 
       # Build up the print area range "=Sheet2!R1C1:R2C1"
       @print_area = convert_name_area(row1, col1, row2, col2)
+      @print_area.dup
     end
 
     #
@@ -1321,7 +1466,7 @@ module Writexlsx
     def set_zoom(scale = 100)
       # Confine the scale to Excel's range
       if scale < 10 or scale > 400
-        # carp "Zoom factor $scale outside range: 10 <= zoom <= 400"
+        # carp "Zoom factor scale outside range: 10 <= zoom <= 400"
         scale = 100
       end
 
@@ -1489,7 +1634,7 @@ module Writexlsx
     #     format.set_color('red')
     #     format.set_align('center')
     #
-    #     worksheet.write(4, 0, 'Hello', $format)    # Formatted string
+    #     worksheet.write(4, 0, 'Hello', format)    # Formatted string
     #
     # The write() method will ignore empty strings or nil tokens unless a format
     # is also supplied. As such you needn't worry about special handling for
@@ -1864,14 +2009,14 @@ module Writexlsx
     # This option is used to change the x offset, in pixels, of a comment
     # within a cell:
     #
-    #     worksheet.write_comment('C3', $comment, :x_offset => 30)
+    #     worksheet.write_comment('C3', comment, :x_offset => 30)
     #
     # ===Option: y_offset
     #
     # This option is used to change the y offset, in pixels, of a comment
     # within a cell:
     #
-    #     worksheet.write_comment('C3', $comment, :x_offset => 30)
+    #     worksheet.write_comment('C3', comment, :x_offset => 30)
     #
     # You can apply as many of these options as you require.
     #
@@ -1882,7 +2027,7 @@ module Writexlsx
     # mouse over them.
     #
     # Note about row height and comments. If you specify the height of a
-    # row that contains a comment then Excel::Writer::XLSX will adjust the
+    # row that contains a comment then WriteXLSX will adjust the
     # height of the comment to maintain the default or user specified
     # dimensions. However, the height of a row can also be adjusted
     # automatically by Excel if the text wrap property is set or large
@@ -1900,14 +2045,8 @@ module Writexlsx
       check_dimensions(row, col)
       store_row_col_max_min_values(row, col)
 
-      @has_comments = true
       # Process the properties of the cell comment.
-      if @comments[row]
-        @comments[row][col] = comment_params(row, col, string, options)
-      else
-        @comments[row] = {}
-        @comments[row][col] = comment_params(row, col, string, options)
-      end
+      @comments.add(Package::Comment.new(@workbook, self, row, col, string, options))
     end
 
     #
@@ -1939,8 +2078,7 @@ module Writexlsx
       check_dimensions(row, col)
       store_row_col_max_min_values(row, col)
 
-      store_data_to_table(row, col, [type, num, xf])
-      0
+      store_data_to_table(NumberCellData.new(row, col, num, xf))
     end
 
     #
@@ -1950,8 +2088,6 @@ module Writexlsx
     # Write a string to the specified row and column (zero indexed).
     # format is optional.
     #
-    #   Returns  0 : normal termination
-    #
     #     worksheet.write_string(0, 0, 'Your text here')
     #     worksheet.write_string('A2', 'or here')
     #
@@ -1979,22 +2115,13 @@ module Writexlsx
       row, col, str, xf = row_col_notation(args)
       raise WriteXLSXInsufficientArgumentError if [row, col, str].include?(nil)
 
-      type = 's'                    # The data type
-
       # Check that row and col are valid and store max and min values
       check_dimensions(row, col)
       store_row_col_max_min_values(row, col)
 
-      # Check that the string is < 32767 chars
-      str_error = 0
-      if str.length > @xls_strmax
-        str = str[0, @xls_strmax]
-      end
-
-      index = shared_string_index(str)
+      index = shared_string_index(str[0, STR_MAX])
 
-      store_data_to_table(row, col, [type, index, xf])
-      str_error
+      store_data_to_table(StringCellData.new(row, col, index, xf))
     end
 
     #
@@ -2115,7 +2242,7 @@ module Writexlsx
       # If the first token is a string start the <r> element.
       writer.start_tag('r') if !fragments[0].respond_to?(:get_xf_index)
 
-      # Write the XML elements for the $format $string fragments.
+      # Write the XML elements for the format string fragments.
       fragments.each do |token|
         if token.respond_to?(:get_xf_index)
           # Write the font run.
@@ -2134,7 +2261,7 @@ module Writexlsx
       # Add the XML string to the shared string table.
       index = shared_string_index(writer.string)
 
-      store_data_to_table(row, col, [type, index, xf])
+      store_data_to_table(StringCellData.new(row, col, index, xf))
     end
 
     #
@@ -2172,13 +2299,11 @@ module Writexlsx
       # Don't write a blank cell unless it has a format
       return unless xf
 
-      type = 'b'                    # The data type
-
       # Check that row and col are valid and store max and min values
       check_dimensions(row, col)
       store_row_col_max_min_values(row, col)
 
-      store_data_to_table(row, col, [type, nil, xf])
+      store_data_to_table(BlankCellData.new(row, col,  nil, xf))
     end
 
     #
@@ -2227,7 +2352,7 @@ module Writexlsx
 
       formula.sub!(/^=/, '')
 
-      store_data_to_table(row, col, ['f', formula, format, value])
+      store_data_to_table(FormulaCellData.new(row, col, formula, format, value))
     end
 
     #
@@ -2238,9 +2363,6 @@ module Writexlsx
     #
     # format is optional.
     #
-    # write_array_formula methods return:
-    #   Returns  0 : normal termination
-    #
     # In Excel an array formula is a formula that performs a calculation
     # on a set of values. It can return a single value or a range of values.
     #
@@ -2284,8 +2406,6 @@ module Writexlsx
       row1, col1, row2, col2, formula, xf, value = row_col_notation(args)
       raise WriteXLSXInsufficientArgumentError if [row1, col1, row2, col2, formula].include?(nil)
 
-      type = 'a'                    # The data type
-
       # Swap last row/col with first row/col as necessary
       row1, row2 = row2, row1 if row1 > row2
       col1, col2 = col2, col1 if col1 > col2
@@ -2305,7 +2425,7 @@ module Writexlsx
       formula.sub!(/^\{(.*)\}$/, '\1')
       formula.sub!(/^=/, '')
 
-      store_data_to_table(row1, col1, [type, formula, xf, range, value])
+      store_data_to_table(FormulaArrayCellData.new(row1, col1, formula, xf, range, value))
     end
 
     # The outline_settings() method is used to control the appearance of
@@ -2424,6 +2544,7 @@ module Writexlsx
     def write_url(*args)
       # Check for a cell reference in A1 notation and substitute row and column
       row, col, url, xf, str, tip = row_col_notation(args)
+      xf, str = str, xf if str.respond_to?(:xf_index)
       raise WriteXLSXInsufficientArgumentError if [row, col, url].include?(nil)
 
       type      = 'l'                       # XML data type
@@ -2455,14 +2576,8 @@ module Writexlsx
       check_dimensions(row, col)
       store_row_col_max_min_values(row, col)
 
-      # Check that the string is < 32767 chars
-      str_error = 0
-      if str.bytesize > @xls_strmax
-        str = str[0, @xls_strmax]
-      end
-
       # Store the URL displayed text in the shared string table.
-      index = shared_string_index(str)
+      index = shared_string_index(str[0, STR_MAX])
 
       # External links to URLs and to other Excel workbooks have slightly
       # different characteristics that we have to account for.
@@ -2484,9 +2599,7 @@ module Writexlsx
         link_type = 1
       end
 
-      store_data_to_table(row, col, [type, index, xf, link_type, url, str, tip])
-
-      return str_error
+      store_data_to_table(HyperlinkCellData.new(row, col, index, xf, link_type, url, str, tip))
     end
 
     #
@@ -2494,7 +2607,7 @@ module Writexlsx
     #   write_date_time (row, col, date_string [ , format ] )
     #
     # Write a datetime string in ISO8601 "yyyy-mm-ddThh:mm:ss.ss" format as a
-    # number representing an Excel date. $format is optional.
+    # number representing an Excel date. format is optional.
     #
     # The write_date_time() method can be used to write a date or time
     # to the cell specified by row and column:
@@ -2508,7 +2621,7 @@ module Writexlsx
     # This conforms to an ISO8601 date but it should be noted that the
     # full range of ISO8601 formats are not supported.
     #
-    # The following variations on the $date_string parameter are permitted:
+    # The following variations on the date_string parameter are permitted:
     #
     #     yyyy-mm-ddThh:mm:ss.sss         # Standard format
     #     yyyy-mm-ddT                     # No time
@@ -2519,7 +2632,7 @@ module Writexlsx
     #
     # Note that the T is required in all cases.
     #
-    # A date should always have a $format, otherwise it will appear
+    # A date should always have a format, otherwise it will appear
     # as a number, see "DATES AND TIME IN EXCEL" and "CELL FORMATTING".
     # Here is a typical example:
     #
@@ -2537,20 +2650,15 @@ module Writexlsx
       row, col, str, xf = row_col_notation(args)
       raise WriteXLSXInsufficientArgumentError if [row, col, str].include?(nil)
 
-      type = 'n'                    # The data type
-
       # Check that row and col are valid and store max and min values
       check_dimensions(row, col)
       store_row_col_max_min_values(row, col)
 
-      str_error = 0
       date_time = convert_date_time(str)
 
       # If the date isn't valid then write it as a string.
       return write_string(args) unless date_time
-      store_data_to_table(row, col, [type, date_time, xf])
-
-      str_error
+      store_data_to_table(NumberCellData.new(row, col, date_time, xf))
     end
 
     #
@@ -2632,7 +2740,7 @@ module Writexlsx
     # cell. This can be occasionally useful if you wish to align two or more
     # images relative to the same cell.
     #
-    # The parameters $scale_x and $scale_y can be used to scale the inserted
+    # The parameters scale_x and scale_y can be used to scale the inserted
     # image horizontally and vertically:
     #
     #     # Scale the inserted image: width x 2.0, height x 0.8
@@ -2712,7 +2820,7 @@ module Writexlsx
     end
 
     #
-    # convert_date_time($date_time_string)
+    # convert_date_time(date_time_string)
     #
     # The function takes a date and time in ISO8601 "yyyy-mm-ddThh:mm:ss.ss" format
     # and converts it to a decimal number representing a valid Excel date.
@@ -2852,14 +2960,14 @@ module Writexlsx
     # don't have a format. For example
     #
     #     worksheet.set_row(0, nil, format1)      # Set the format for row 1
-    #     worksheet.write('A1', 'Hello')          # Defaults to $format1
-    #     worksheet.write('B1', 'Hello', format2) # Keeps $format2
+    #     worksheet.write('A1', 'Hello')          # Defaults to format1
+    #     worksheet.write('B1', 'Hello', format2) # Keeps format2
     #
     # If you wish to define a row format in this way you should call the
     # method before any calls to write(). Calling it afterwards will overwrite
     # any format that was previously specified.
     #
-    # The $hidden parameter should be set to 1 if you wish to hide a row.
+    # The hidden parameter should be set to 1 if you wish to hide a row.
     # This can be used, for example, to hide intermediary steps in a
     # complicated calculation:
     #
@@ -2892,7 +3000,7 @@ module Writexlsx
     # programs in the examples directory of the distro.
     #
     # Excel allows up to 7 outline levels. Therefore the level parameter
-    # should be in the range 0 <= $level <= 7.
+    # should be in the range 0 <= level <= 7.
     #
     def set_row(*args)
       row = args[0]
@@ -2931,7 +3039,7 @@ module Writexlsx
     end
 
     #
-    # merge_range($first_row, $first_col, $last_row, $last_col, $string, $format)
+    # merge_range(first_row, first_col, last_row, last_col, string, format)
     #
     # Merge a range of cells. The first cell should contain the data and the others
     # should be blank. All cells should contain the same format.
@@ -3029,9 +3137,6 @@ module Writexlsx
     #    conditional_formatting(row, col, {...})
     #    conditional_formatting(first_row, first_col, last_row, last_col, {...})
     #
-    # conditional_formatting methods return:
-    #   Returns  0 : normal termination
-    #
     # The conditional_format() method is used to add formatting to a cell
     # or range of cells based on user defined criteria.
     #
@@ -3040,14 +3145,14 @@ module Writexlsx
     #             :type     => 'cell',
     #             :criteria => '>=',
     #             :value    => 50,
-    #             :format   => $format1
+    #             :format   => format1
     #         }
     #     )
     #
     # This method contains a lot of parameters and is described in detail in
     # a separate section "CONDITIONAL FORMATTING IN EXCEL".
     #
-    # See also the conditional_format.pl program in the examples directory of the distro
+    # See also the conditional_format.rb program in the examples directory of the distro
     #
     def conditional_formatting(*args)
       # Check for a cell reference in A1 notation and substitute row and column
@@ -3486,7 +3591,7 @@ module Writexlsx
     #             :input_title   => 'Enter an integer:',
     #             :input_message => 'between 1 and 100',
     #         });
-    # See also the data_validate.pl program in the examples directory
+    # See also the data_validate.rb program in the examples directory
     # of the distro.
     #
     def data_validation(*args)
@@ -3502,111 +3607,38 @@ module Writexlsx
       end
       raise WriteXLSXInsufficientArgumentError if [row1, col1, row2, col2, param].include?(nil)
 
-      # Check that row and col are valid without storing the values.
       check_dimensions(row1, col1)
       check_dimensions(row2, col2)
 
-      # Check for valid input parameters.
-      param.each_key do |param_key|
-        unless valid_validation_parameter.include?(param_key)
-          raise WriteXLSXOptionParameterError, "Unknown parameter '#{param_key}' in data_validation()"
-        end
-      end
+      check_for_valid_input_params(param)
 
-      # Map alternative parameter names 'source' or 'minimum' to 'value'.
       param[:value] = param[:source]  if param[:source]
       param[:value] = param[:minimum] if param[:minimum]
 
-      # :validate is a required parameter.
-      unless param.has_key?(:validate)
-        raise WriteXLSXOptionParameterError, "Parameter :validate is required in data_validation()"
-      end
-
-      # Check for valid validation types.
-      unless valid_validation_type.has_key?(param[:validate].downcase)
-        raise WriteXLSXOptionParameterError,
-          "Unknown validation type '#{param[:validate]}' for parameter :validate in data_validation()"
-      else
-        param[:validate] = valid_validation_type[param[:validate].downcase]
-      end
-
-      # No action is required for validation type 'any'.
-      # TODO: we should perhaps store 'any' for message only validations.
+      param[:validate] = valid_validation_type[param[:validate].downcase]
       return if param[:validate] == 'none'
-
-      # The list and custom validations don't have a criteria so we use a default
-      # of 'between'.
-      if param[:validate] == 'list' || param[:validate] == 'custom'
+      if ['list', 'custom'].include?(param[:validate])
         param[:criteria]  = 'between'
         param[:maximum]   = nil
       end
 
-      # 'criteria' is a required parameter.
-      unless param.has_key?(:criteria)
-        raise WriteXLSXOptionParameterError, "Parameter :criteria is required in data_validation()"
-      end
-
-      # List of valid criteria types.
-      criteria_type = valid_criteria_type
-
-      # Check for valid criteria types.
-      unless criteria_type.has_key?(param[:criteria].downcase)
-        raise WriteXLSXOptionParameterError,
-          "Unknown criteria type '#{param[:criteria]}' for parameter :criteria in data_validation()"
-      else
-        param[:criteria] = criteria_type[param[:criteria].downcase]
-      end
-
-      # 'Between' and 'Not between' criteria require 2 values.
-      if param[:criteria] == 'between' || param[:criteria] == 'notBetween'
-        unless param.has_key?(:maximum)
-          raise WriteXLSXOptionParameterError,
-            "Parameter :maximum is required in data_validation() when using :between or :not between criteria"
-        end
-      else
-        param[:maximum] = nil
-      end
-
-      # List of valid error dialog types.
-      error_type = {
-        'stop'        => 0,
-        'warning'     => 1,
-        'information' => 2
-      }
-
-      # Check for valid error dialog types.
-      if not param.has_key?(:error_type)
-        param[:error_type] = 0
-      elsif not error_type.has_key?(param[:error_type].downcase)
-        raise WriteXLSXOptionParameterError,
-          "Unknown criteria type '#param[:error_type}' for parameter :error_type in data_validation()"
-      else
-        param[:error_type] = error_type[param[:error_type].downcase]
-      end
+      check_criteria_required(param)
+      check_valid_citeria_types(param)
+      param[:criteria] = valid_criteria_type[param[:criteria].downcase]
 
-      # Convert date/times value if required.
-      if param[:validate] == 'date' || param[:validate] == 'time'
-        unless convert_date_time_value(param, :value) && convert_date_time_value(param, :maximum)
-          raise WriteXLSXOptionParameterError, "Invalid date/time value."
-        end
-      end
+      check_maximum_value_when_criteria_is_between_or_notbetween(param)
+      param[:error_type] = param.has_key?(:error_type) ? error_type[param[:error_type].downcase] : 0
 
-      # Set some defaults if they haven't been defined by the user.
-      param[:ignore_blank]  = 1 unless param[:ignore_blank]
-      param[:dropdown]      = 1 unless param[:dropdown]
-      param[:show_input]    = 1 unless param[:show_input]
-      param[:show_error]    = 1 unless param[:show_error]
+      convert_date_time_value_if_required(param)
+      set_some_defaults(param)
 
-      # These are the cells to which the validation is applied.
       param[:cells] = [[row1, col1, row2, col2]]
 
       # A (for now) undocumented parameter to pass additional cell ranges.
-      if param.has_key?(:other_cells)
-        param[:other_cells].each { |cells| param[:cells] << cells }
-      end
+      param[:other_cells].each { |cells| param[:cells] << cells } if param.has_key?(:other_cells)
 
       # Store the validation information until we close the worksheet.
-      @validations.push(param)
+      @validations << param
     end
 
     #
@@ -4010,8 +4042,12 @@ module Writexlsx
       @comments_author = author if author
     end
 
+    def comments_count # :nodoc:
+      @comments.size
+    end
+
     def has_comments? # :nodoc:
-      !!@has_comments
+      !@comments.empty?
     end
 
     def is_chartsheet? # :nodoc:
@@ -4022,42 +4058,26 @@ module Writexlsx
     # Turn the HoH that stores the comments into an array for easier handling
     # and set the external links.
     #
-    def prepare_comments(vml_data_id, vml_shape_id, comment_id) # :nodoc:
-      comments = []
-
-      # We sort the comments by row and column but that isn't strictly required.
-      @comments.keys.sort.each do |row|
-        @comments[row].keys.sort.each do |col|
-          # Set comment visibility if required and not already user defined.
-          @comments[row][col][4] ||= 1 if @comments_visible
-
-          # Set comment author if not already user defined.
-          @comments[row][col][3] ||= @comments_author
-          comments << @comments[row][col]
-        end
-      end
-
-      @comments_array = comments
-
-      @external_comment_links <<
-        ['/vmlDrawing', "../drawings/vmlDrawing#{comment_id}.vml"] <<
-        ['/comments',   "../comments#{comment_id}.xml"]
-
-      count         = comments.size
+    def set_vml_data_id(vml_data_id) # :nodoc:
+      count = @comments.sorted_comments.size
       start_data_id = vml_data_id
 
       # The VML o:idmap data id contains a comma separated range when there is
       # more than one 1024 block of comments, like this: data="1,2".
       (1 .. (count / 1024)).each do |i|
-        vml_data_id = "vml_data_id,#{start_data_id + i}"
+        vml_data_id = "#{vml_data_id},#{start_data_id + i}"
       end
-
-      @vml_data_id  = vml_data_id
-      @vml_shape_id = vml_shape_id
+      @vml_data_id = vml_data_id
 
       count
     end
 
+    def set_external_comment_links(comment_id) # :nodoc:
+      @external_comment_links <<
+        ['/vmlDrawing', "../drawings/vmlDrawing#{comment_id}.vml"] <<
+        ['/comments',   "../comments#{comment_id}.xml"]
+    end
+
     #
     # Set up chart/drawings.
     #
@@ -4094,43 +4114,21 @@ module Writexlsx
     # Return nils for data that doesn't exist since Excel can chart series
     # with data missing.
     #
-    def get_range_data(row_start, col_start, row_end, col_end)
+    def get_range_data(row_start, col_start, row_end, col_end) # :nodoc:
       # TODO. Check for worksheet limits.
 
       # Iterate through the table data.
       data = []
       (row_start .. row_end).each do |row_num|
         # Store nil if row doesn't exist.
-        if !@table[row_num]
+        if !@cell_data_table[row_num]
           data << nil
           next
         end
 
         (col_start .. col_end).each do |col_num|
-          if cell = @table[row_num][col_num]
-            type  = cell[0]
-            token = cell[1]
-
-            data << case type
-            when 'n'
-              # Store a number.
-              token
-            when 's'
-              # Store a string.
-              {:sst_id => token}
-            when 'f'
-              # Store a formula.
-              cell[3] || 0
-            when 'a'
-              # Store an array formula.
-              cell[4] || 0
-            when 'l'
-              # Store the string part a hyperlink.
-              {:sst_id => token}
-            when 'b'
-              # Store a empty cell.
-              ''
-            end
+          if cell = @cell_data_table[row_num][col_num]
+            data << cell.data
           else
             # Store nil if col doesn't exist.
             data << nil
@@ -4141,49 +4139,262 @@ module Writexlsx
       return data
     end
 
-    private
+    #
+    # Calculate the vertices that define the position of a graphical object within
+    # the worksheet in pixels.
+    #
+    #         +------------+------------+
+    #         |     A      |      B     |
+    #   +-----+------------+------------+
+    #   |     |(x1,y1)     |            |
+    #   |  1  |(A1)._______|______      |
+    #   |     |    |              |     |
+    #   |     |    |              |     |
+    #   +-----+----|    BITMAP    |-----+
+    #   |     |    |              |     |
+    #   |  2  |    |______________.     |
+    #   |     |            |        (B2)|
+    #   |     |            |     (x2,y2)|
+    #   +---- +------------+------------+
+    #
+    # Example of an object that covers some of the area from cell A1 to cell B2.
+    #
+    # Based on the width and height of the object we need to calculate 8 vars:
+    #
+    #     col_start, row_start, col_end, row_end, x1, y1, x2, y2.
+    #
+    # We also calculate the absolute x and y position of the top left vertex of
+    # the object. This is required for images.
+    #
+    #    x_abs, y_abs
+    #
+    # The width and height of the cells that the object occupies can be variable
+    # and have to be taken into account.
+    #
+    # The values of col_start and row_start are passed in from the calling
+    # function. The values of col_end and row_end are calculated by subtracting
+    # the width and height of the object from the width and height of the
+    # underlying cells.
+    #
+    #    col_start    # Col containing upper left corner of object.
+    #    x1           # Distance to left side of object.
+    #    row_start    # Row containing top left corner of object.
+    #    y1           # Distance to top of object.
+    #    col_end      # Col containing lower right corner of object.
+    #    x2           # Distance to right side of object.
+    #    row_end      # Row containing bottom right corner of object.
+    #    y2           # Distance to bottom of object.
+    #    width        # Width of object frame.
+    #    height       # Height of object frame.
+    def position_object_pixels(col_start, row_start, x1, y1, width, height, is_drawing = false) #:nodoc:
+      # Calculate the absolute x offset of the top-left vertex.
+      if @col_size_changed
+        x_abs = (1 .. col_start).inject(0) {|sum, col| sum += size_col(col)}
+      else
+        # Optimisation for when the column widths haven't changed.
+        x_abs = 64 * col_start
+      end
+      x_abs += x1
 
-    # List of valid input parameters.
-    def valid_validation_parameter
-      [
-        :validate,
-        :criteria,
-        :value,
-        :source,
-        :minimum,
-        :maximum,
-        :ignore_blank,
-        :dropdown,
-        :show_input,
-        :input_title,
-        :input_message,
-        :show_error,
-        :error_title,
-        :error_message,
-        :error_type,
-        :other_cells
-      ]
-    end
+      # Calculate the absolute y offset of the top-left vertex.
+      # Store the column change to allow optimisations.
+      if @row_size_changed
+        y_abs = (1 .. row_start).inject(0) {|sum, row| sum += size_row(row)}
+      else
+        # Optimisation for when the row heights haven't changed.
+        y_abs = 20 * row_start
+      end
+      y_abs += y1
 
-    def valid_validation_type # :nodoc:
-      {
-        'any'             => 'none',
-        'any value'       => 'none',
-        'whole number'    => 'whole',
-        'whole'           => 'whole',
-        'integer'         => 'whole',
-        'decimal'         => 'decimal',
-        'list'            => 'list',
-        'date'            => 'date',
-        'time'            => 'time',
-        'text length'     => 'textLength',
+      # Adjust start column for offsets that are greater than the col width.
+      x1, col_start = adjust_column_offset(x1, col_start)
+
+      # Adjust start row for offsets that are greater than the row height.
+      y1, row_start = adjust_row_offset(y1, row_start)
+
+      # Initialise end cell to the same as the start cell.
+      col_end = col_start
+      row_end = row_start
+
+      width  += x1
+      height += y1
+
+      # Subtract the underlying cell widths to find the end cell of the object.
+      width, col_end = adjust_column_offset(width, col_end)
+
+      # Subtract the underlying cell heights to find the end cell of the object.
+      height, row_end = adjust_row_offset(height, row_end)
+
+      # The following is only required for positioning drawing/chart objects
+      # and not comments. It is probably the result of a bug.
+      if is_drawing
+        col_end -= 1 if width == 0
+        row_end -= 1 if height == 0
+      end
+
+      # The end vertices are whatever is left from the width and height.
+      x2 = width
+      y2 = height
+
+      [col_start, row_start, x1, y1, col_end, row_end, x2, y2, x_abs, y_abs]
+    end
+
+    def comments_visible? # :nodoc:
+      !!@comments_visible
+    end
+
+    def comments_xml_writer=(file) # :nodoc:
+      @comments.set_xml_writer(file)
+    end
+
+    def comments_assemble_xml_file # :nodoc:
+      @comments.assemble_xml_file
+    end
+
+    def comments_array # :nodoc:
+      @comments.sorted_comments
+    end
+
+    #
+    # Write the cell value <v> element.
+    #
+    def write_cell_value(value = '') #:nodoc:
+      value ||= ''
+      value = value.to_i if value == value.to_i
+      @writer.data_element('v', value)
+    end
+
+    #
+    # Write the cell formula <f> element.
+    #
+    def write_cell_formula(formula = '') #:nodoc:
+      @writer.data_element('f', formula)
+    end
+
+    #
+    # Write the cell array formula <f> element.
+    #
+    def write_cell_array_formula(formula, range) #:nodoc:
+      attributes = ['t', 'array', 'ref', range]
+
+      @writer.data_element('f', formula, attributes)
+    end
+
+    private
+
+    def check_for_valid_input_params(param)
+      param.each_key do |param_key|
+        unless valid_validation_parameter.include?(param_key)
+          raise WriteXLSXOptionParameterError, "Unknown parameter '#{param_key}' in data_validation()"
+        end
+      end
+      unless param.has_key?(:validate)
+        raise WriteXLSXOptionParameterError, "Parameter :validate is required in data_validation()"
+      end
+      unless valid_validation_type.has_key?(param[:validate].downcase)
+        raise WriteXLSXOptionParameterError,
+        "Unknown validation type '#{param[:validate]}' for parameter :validate in data_validation()"
+      end
+      if param[:error_type] && !error_type.has_key?(param[:error_type].downcase)
+        raise WriteXLSXOptionParameterError,
+          "Unknown criteria type '#param[:error_type}' for parameter :error_type in data_validation()"
+      end
+    end
+
+    def check_criteria_required(param)
+      unless param.has_key?(:criteria)
+        raise WriteXLSXOptionParameterError, "Parameter :criteria is required in data_validation()"
+      end
+    end
+
+    def check_valid_citeria_types(param)
+      unless valid_criteria_type.has_key?(param[:criteria].downcase)
+        raise WriteXLSXOptionParameterError,
+          "Unknown criteria type '#{param[:criteria]}' for parameter :criteria in data_validation()"
+      end
+    end
+
+    def check_maximum_value_when_criteria_is_between_or_notbetween(param)
+      if param[:criteria] == 'between' || param[:criteria] == 'notBetween'
+        unless param.has_key?(:maximum)
+          raise WriteXLSXOptionParameterError,
+            "Parameter :maximum is required in data_validation() when using :between or :not between criteria"
+        end
+      else
+        param[:maximum] = nil
+      end
+    end
+
+    def error_type
+      {'stop' => 0, 'warning' => 1, 'information' => 2}
+    end
+
+    def convert_date_time_value_if_required(param)
+      if param[:validate] == 'date' || param[:validate] == 'time'
+        unless convert_date_time_value(param, :value) && convert_date_time_value(param, :maximum)
+          raise WriteXLSXOptionParameterError, "Invalid date/time value."
+        end
+      end
+    end
+
+    def set_some_defaults(param)
+      param[:ignore_blank]  ||= 1
+      param[:dropdown]      ||= 1
+      param[:show_input]    ||= 1
+      param[:show_error]    ||= 1
+    end
+
+    # Minor modification to allow comparison testing. Change RGB colors
+    # from long format, ffcc00 to short format fc0 used by VML.
+    def rgb_color(rgb)
+      result = sprintf("%02x%02x%02x", *rgb)
+      if result =~ /^([0-9a-f])\1([0-9a-f])\2([0-9a-f])\3$/
+        result = "#{$1}#{$2}#{$3}"
+      end
+      result
+    end
+
+    # List of valid input parameters.
+    def valid_validation_parameter
+      [
+        :validate,
+        :criteria,
+        :value,
+        :source,
+        :minimum,
+        :maximum,
+        :ignore_blank,
+        :dropdown,
+        :show_input,
+        :input_title,
+        :input_message,
+        :show_error,
+        :error_title,
+        :error_message,
+        :error_type,
+        :other_cells
+      ]
+    end
+
+    def valid_validation_type # :nodoc:
+      {
+        'any'             => 'none',
+        'any value'       => 'none',
+        'whole number'    => 'whole',
+        'whole'           => 'whole',
+        'integer'         => 'whole',
+        'decimal'         => 'decimal',
+        'list'            => 'list',
+        'date'            => 'date',
+        'time'            => 'time',
+        'text length'     => 'textLength',
         'length'          => 'textLength',
         'custom'          => 'custom'
       }
     end
 
-    # Convert the list of $format, $string tokens to pairs of ($format, $string)
-    # except for the first $string fragment which doesn't require a default
+    # Convert the list of format, string tokens to pairs of (format, string)
+    # except for the first string fragment which doesn't require a default
     # formatting run. Use the default for strings without a leading format.
     def rich_strings_fragments(rich_strings) # :nodoc:
       # Create a temp format with the default font for unformatted fragments.
@@ -4437,68 +4648,6 @@ module Writexlsx
       sprintf("FF%02X%02X%02X", *rgb[0, 3])
     end
 
-    #
-    # Substitute an Excel cell reference in A1 notation for  zero based row and
-    # column values in an argument list.
-    #
-    # Ex: ("A4", "Hello") is converted to (3, 0, "Hello").
-    #
-    def substitute_cellref(cell, *args)       #:nodoc:
-      return [*args] if cell.respond_to?(:coerce) # Numeric
-
-      cell.upcase!
-
-      case cell
-      # Convert a column range: 'A:A' or 'B:G'.
-      # A range such as A:A is equivalent to A1:65536, so add rows as required
-      when /\$?([A-Z]{1,3}):\$?([A-Z]{1,3})/
-        row1, col1 =  cell_to_rowcol($1 + '1')
-        row2, col2 =  cell_to_rowcol($2 + @xls_rowmax.to_s)
-        return [row1, col1, row2, col2, *args]
-      # Convert a cell range: 'A1:B7'
-      when /\$?([A-Z]{1,3}\$?\d+):\$?([A-Z]{1,3}\$?\d+)/
-        row1, col1 =  cell_to_rowcol($1)
-        row2, col2 =  cell_to_rowcol($2)
-        return [row1, col1, row2, col2, *args]
-      # Convert a cell reference: 'A1' or 'AD2000'
-      when /\$?([A-Z]{1,3}\$?\d+)/
-        row1, col1 =  cell_to_rowcol($1)
-        return [row1, col1, *args]
-      else
-        raise("Unknown cell reference #{cell}")
-      end
-    end
-
-    #
-    # Convert an Excel cell reference in A1 notation to a zero based row and column
-    # reference converts C1 to (0, 2).
-    #
-    # Returns: row, column
-    #
-    def cell_to_rowcol(cell)       #:nodoc:
-      cell =~ /(\$?)([A-Z]{1,3})(\$?)(\d+)/
-      col_abs = $1 == '' ? 0 : 1
-      col     = $2
-      row_abs = $3 == '' ? 0 : 1
-      row     = $4.to_i
-
-      # Convert base26 column string to number
-      # All your Base are belong to us.
-      chars = col.split(//)
-      expn = 0
-      col = 0
-      chars.reverse.each do |char|
-        col += (char.ord - 'A'.ord + 1) * (26 ** expn)
-        expn += 1
-      end
-
-      # Convert 1-index to zero-index
-      row -= 1
-      col -= 1
-
-      [row, col, row_abs, col_abs]
-    end
-
     #
     # This is an internal method that is used to filter elements of the array of
     # pagebreaks used in the _store_hbreak() and _store_vbreak() methods. It:
@@ -4522,106 +4671,6 @@ module Writexlsx
       end
     end
 
-    #
-    # Calculate the vertices that define the position of a graphical object within
-    # the worksheet in pixels.
-    #
-    #         +------------+------------+
-    #         |     A      |      B     |
-    #   +-----+------------+------------+
-    #   |     |(x1,y1)     |            |
-    #   |  1  |(A1)._______|______      |
-    #   |     |    |              |     |
-    #   |     |    |              |     |
-    #   +-----+----|    BITMAP    |-----+
-    #   |     |    |              |     |
-    #   |  2  |    |______________.     |
-    #   |     |            |        (B2)|
-    #   |     |            |     (x2,y2)|
-    #   +---- +------------+------------+
-    #
-    # Example of an object that covers some of the area from cell A1 to cell B2.
-    #
-    # Based on the width and height of the object we need to calculate 8 vars:
-    #
-    #     $col_start, $row_start, $col_end, $row_end, $x1, $y1, $x2, $y2.
-    #
-    # We also calculate the absolute x and y position of the top left vertex of
-    # the object. This is required for images.
-    #
-    #    $x_abs, $y_abs
-    #
-    # The width and height of the cells that the object occupies can be variable
-    # and have to be taken into account.
-    #
-    # The values of $col_start and $row_start are passed in from the calling
-    # function. The values of $col_end and $row_end are calculated by subtracting
-    # the width and height of the object from the width and height of the
-    # underlying cells.
-    #
-    #    col_start    # Col containing upper left corner of object.
-    #    x1           # Distance to left side of object.
-    #    row_start    # Row containing top left corner of object.
-    #    y1           # Distance to top of object.
-    #    col_end      # Col containing lower right corner of object.
-    #    x2           # Distance to right side of object.
-    #    row_end      # Row containing bottom right corner of object.
-    #    y2           # Distance to bottom of object.
-    #    width        # Width of object frame.
-    #    height       # Height of object frame.
-    def position_object_pixels(col_start, row_start, x1, y1, width, height, is_drawing = false) #:nodoc:
-      # Calculate the absolute x offset of the top-left vertex.
-      if @col_size_changed
-        x_abs = (1 .. col_start).inject(0) {|sum, col| sum += size_col(col)}
-      else
-        # Optimisation for when the column widths haven't changed.
-        x_abs = 64 * col_start
-      end
-      x_abs += x1
-
-      # Calculate the absolute y offset of the top-left vertex.
-      # Store the column change to allow optimisations.
-      if @row_size_changed
-        y_abs = (1 .. row_start).inject(0) {|sum, row| sum += size_row(row)}
-      else
-        # Optimisation for when the row heights haven't changed.
-        y_abs = 20 * row_start
-      end
-      y_abs += y1
-
-      # Adjust start column for offsets that are greater than the col width.
-      x1, col_start = adjust_column_offset(x1, col_start)
-
-      # Adjust start row for offsets that are greater than the row height.
-      y1, row_start = adjust_row_offset(y1, row_start)
-
-      # Initialise end cell to the same as the start cell.
-      col_end = col_start
-      row_end = row_start
-
-      width  += x1
-      height += y1
-
-      # Subtract the underlying cell widths to find the end cell of the object.
-      width, col_end = adjust_column_offset(width, col_end)
-
-      # Subtract the underlying cell heights to find the end cell of the object.
-      height, row_end = adjust_row_offset(height, row_end)
-
-      # The following is only required for positioning drawing/chart objects
-      # and not comments. It is probably the result of a bug.
-      if is_drawing
-        col_end -= 1 if width == 0
-        row_end -= 1 if height == 0
-      end
-
-      # The end vertices are whatever is left from the width and height.
-      x2 = width
-      y2 = height
-
-      [col_start, row_start, x1, y1, col_end, row_end, x2, y2, x_abs, y_abs]
-    end
-
     def adjust_column_offset(x, column)
       while x >= size_col(column)
         x -= size_col(column)
@@ -4744,149 +4793,6 @@ module Writexlsx
       @drawing_links << ['/image', "../media/image#{image_id}.#{image_type}"]
     end
 
-    #
-    # This method handles the additional optional parameters to write_comment() as
-    # well as calculating the comment object position and vertices.
-    #
-    def comment_params(row, col, string, options) #:nodoc:
-      options ||= {}
-      default_width  = 128
-      default_height = 74
-
-      params = {
-        :author          => nil,
-        :color           => 81,
-        :start_cell      => nil,
-        :start_col       => nil,
-        :start_row       => nil,
-        :visible         => nil,
-        :width           => default_width,
-        :height          => default_height,
-        :x_offset        => nil,
-        :x_scale         => 1,
-        :y_offset        => nil,
-        :y_scale         => 1
-      }
-
-      # Overwrite the defaults with any user supplied values. Incorrect or
-      # misspelled parameters are silently ignored.
-      params.update(options)
-
-      # Ensure that a width and height have been set.
-      params[:width]  ||= default_width
-      params[:height] ||= default_height
-
-      # Limit the string to the max number of chars.
-      max_len = 32767
-
-      string = string[0, max_len] if string.length > max_len
-
-      # Set the comment background colour.
-      color    = params[:color]
-      color_id = Format.get_color(color)
-
-      if color_id == 0
-        params[:color] = '#ffffe1'
-      else
-        # Get the RGB color from the palette.
-        rgb = @workbook.palette[color_id - 8]
-
-        # Minor modification to allow comparison testing. Change RGB colors
-        # from long format, ffcc00 to short format fc0 used by VML.
-        rgb_color = sprintf("%02x%02x%02x", *rgb)
-
-        if rgb_color =~ /^([0-9a-f])\1([0-9a-f])\2([0-9a-f])\3$/
-          rgb_color = "#{$1}#{$2}#{$3}"
-        end
-
-        params[:color] = sprintf("#%s [%d]\n", rgb_color, color_id)
-      end
-
-      # Convert a cell reference to a row and column.
-      if params[:start_cell]
-        params[:start_row], params[:start_col] = substitute_cellref(params[:start_cell])
-      end
-
-      # Set the default start cell and offsets for the comment. These are
-      # generally fixed in relation to the parent cell. However there are
-      # some edge cases for cells at the, er, edges.
-      #
-      row_max = @xls_rowmax
-      col_max = @xls_colmax
-
-      params[:start_row] ||= case row
-        when 0
-          0
-        when row_max - 3
-          row_max - 7
-        when row_max - 2
-          row_max - 6
-        when row_max - 1
-          row_max - 5
-        else
-          row - 1
-      end
-
-      params[:y_offset] ||= case row
-        when 0
-          2
-        when row_max - 3, row_max - 2
-          16
-        when row_max - 1
-          14
-        else
-          10
-      end
-
-      params[:start_col] ||= case col
-        when col_max - 3
-          col_max - 6
-        when col_max - 2
-          col_max - 5
-        when col_max - 1
-          col_max - 4
-        else
-          col + 1
-      end
-
-      params[:x_offset] ||= case col
-        when col_max - 3, col_max - 2, col_max - 1
-          49
-        else
-          15
-      end
-
-      # Scale the size of the comment box if required.
-      params[:width] = params[:width] * params[:x_scale] if params[:x_scale]
-
-      params[:height] = params[:height] * params[:y_scale] if params[:y_scale]
-
-      # Round the dimensions to the nearest pixel.
-      params[:width]  = (0.5 + params[:width]).to_i
-      params[:height] = (0.5 + params[:height]).to_i
-
-      # Calculate the positions of comment object.
-      vertices = position_object_pixels(
-        params[:start_col], params[:start_row], params[:x_offset],
-        params[:y_offset],  params[:width],     params[:height]
-       )
-
-      # Add the width and height for VML.
-      vertices << [params[:width], params[:height]]
-
-      return [
-        row,
-        col,
-        string,
-
-        params[:author],
-        params[:visible],
-        params[:color],
-
-        vertices
-      ]
-    end
-
     #
     # Based on the algorithm provided by Daniel Rentz of OpenOffice.
     #
@@ -5076,21 +4982,15 @@ module Writexlsx
     # Write the <col> element.
     #
     def write_col_info(*args) #:nodoc:
-      min = args[0] || 0
-      max = args[1] || 0
-      width = args[2]
-      format = args[3]
-      hidden = args[4] || 0
-      level = args[5] || 0
-      collapsed = args[6] || 0
-#          min          = $_[0] // 0    # First formatted column.
-#          max          = $_[1] // 0    # Last formatted column.
-#          width        = $_[2]         # Col width in user units.
-#          format       = $_[3]         # Format index.
-#          hidden       = $_[4] // 0    # Hidden flag.
-#          level        = $_[5] // 0    # Outline level.
-#          collapsed    = $_[6] // 0    # Outline level.
-      custom_width = 1
+      min    = args[0] || 0     # First formatted column.
+      max    = args[1] || 0     # Last formatted column.
+      width  = args[2]          # Col width in user units.
+      format = args[3]          # Format index.
+      hidden = args[4] || 0     # Hidden flag.
+      level  = args[5] || 0     # Outline level.
+      collapsed = args[6] || 0  # Outline level.
+
+      custom_width = true
       xf_index = 0
       xf_index = format.get_xf_index if format.respond_to?(:get_xf_index)
 
@@ -5098,13 +4998,13 @@ module Writexlsx
       if width.nil?
         if hidden == 0
           width        = 8.43
-          custom_width = 0
+          custom_width = false
         else
           width = 0
         end
       else
         # Width is defined but same as default.
-        custom_width = 0 if width == 8.43
+        custom_width = false if width == 8.43
       end
 
       # Convert column width from user units to character width.
@@ -5121,7 +5021,7 @@ module Writexlsx
 
       (attributes << 'style' << xf_index) if xf_index != 0
       (attributes << 'hidden' << 1)       if hidden != 0
-      (attributes << 'customWidth' << 1)  if custom_width != 0
+      (attributes << 'customWidth' << 1)  if custom_width
       (attributes << 'outlineLevel' << level) if level != 0
       (attributes << 'collapsed'    << 1) if collapsed != 0
 
@@ -5156,7 +5056,7 @@ module Writexlsx
         span       = @row_spans[span_index]
 
         # Write the cells if the row contains data.
-        if @table[row_num]
+        if @cell_data_table[row_num]
           if !@set_rows[row_num]
             write_row_element(row_num, span)
           else
@@ -5188,8 +5088,7 @@ module Writexlsx
       return not_contain_formatting_or_data?(row_num)
 
       # Write the cells if the row contains data.
-      row_ref = @table[row_num]
-      if row_ref
+      if @cell_data_table[row_num]
         if !@set_rows[row_num]
           write_row(row_num)
         else
@@ -5204,17 +5103,16 @@ module Writexlsx
       end
 
       # Reset table.
-      @table = []
+      @cell_data_table = {}
     end
 
     def not_contain_formatting_or_data?(row_num) # :nodoc:
-      !@set_rows[row_num] && !@table[row_num] && !@comments[row_num]
+      !@set_rows[row_num] && !@cell_data_table[row_num] && !@comments.has_comment_in_row?(row_num)
     end
 
     def write_cell_column_dimension(row_num)  # :nodoc:
       (@dim_colmin .. @dim_colmax).each do |col_num|
-        col_ref = @table[row_num][col_num]
-        write_cell(row_num, col_num, col_ref) if col_ref
+        @cell_data_table[row_num][col_num].write_cell(self) if @cell_data_table[row_num][col_num]
       end
     end
 
@@ -5258,121 +5156,6 @@ module Writexlsx
         write_row_element(*new_args)
     end
 
-    #
-    # Write the <cell> element. This is the innermost loop so efficiency is
-    # important where possible. The basic methodology is that the data of every
-    # cell type is passed in as follows:
-    #
-    #      [ $row, $col, $aref]
-    #
-    # The aref, called $cell below, contains the following structure in all types:
-    #
-    #     [ $type, $token, $xf, @args ]
-    #
-    # Where $type:  represents the cell type, such as string, number, formula, etc.
-    #       $token: is the actual data for the string, number, formula, etc.
-    #       $xf:    is the XF format object index.
-    #       @args:  additional args relevant to the specific data type.
-    #
-    def write_cell(row, col, cell) #:nodoc:
-      type, token, xf = cell
-
-      xf_index = 0
-      xf_index = xf.get_xf_index if xf.respond_to?(:get_xf_index)
-
-      range = xl_rowcol_to_cell(row, col)
-      attributes = ['r', range]
-
-      # Add the cell format index.
-      if xf_index != 0
-        attributes << 's' << xf_index
-      elsif @set_rows[row] && @set_rows[row][1]
-        row_xf = @set_rows[row][1]
-        attributes << 's' << row_xf.get_xf_index
-      elsif @col_formats[col]
-        col_xf = @col_formats[col]
-        attributes << 's' << col_xf.get_xf_index
-      end
-
-      # Write the various cell types.
-      case type
-      when 'n'
-        # Write a number.
-        @writer.start_tag('c', attributes)
-        write_cell_value(token)
-        @writer.end_tag('c')
-      when 's'
-        # Write a string.
-        attributes << 't' << 's'
-        @writer.start_tag('c', attributes)
-        write_cell_value(token)
-        @writer.end_tag('c')
-      when 'f'
-        # Write a formula.
-        @writer.start_tag('c', attributes)
-        write_cell_formula(token)
-        write_cell_value(cell[3] || 0)
-        @writer.end_tag('c')
-      when 'a'
-        # Write an array formula.
-        @writer.start_tag('c', attributes)
-        write_cell_array_formula(token, cell[3])
-        write_cell_value(cell[4])
-        @writer.end_tag('c')
-      when 'l'
-        link_type = cell[3]
-
-        # Write the string part a hyperlink.
-        attributes << 't' << 's'
-        @writer.start_tag('c', attributes)
-        write_cell_value(token)
-        @writer.end_tag('c')
-
-        if link_type == 1
-          # External link with rel file relationship.
-          @hlink_count += 1
-          @hlink_refs <<
-            [
-              link_type,    row,     col,
-              @hlink_count, cell[5], cell[6]
-            ]
-
-          @external_hyper_links << [ '/hyperlink', cell[4], 'External' ]
-        elsif link_type
-          # External link with rel file relationship.
-          @hlink_refs << [link_type, row, col, cell[4], cell[5], cell[6] ]
-        end
-      when 'b'
-        # Write a empty cell.
-        @writer.empty_tag('c', attributes)
-      end
-    end
-
-    #
-    # Write the cell value <v> element.
-    #
-    def write_cell_value(value = '') #:nodoc:
-      value ||= ''
-      value = value.to_i if value == value.to_i
-      @writer.data_element('v', value)
-    end
-
-    #
-    # Write the cell formula <f> element.
-    #
-    def write_cell_formula(formula = '') #:nodoc:
-      @writer.data_element('f', formula)
-    end
-
-    #
-    # Write the cell array formula <f> element.
-    #
-    def write_cell_array_formula(formula, range) #:nodoc:
-      attributes = ['t', 'array', 'ref', range]
-
-      @writer.data_element('f', formula, attributes)
-    end
-
     #
     # Write the frozen or split <pane> elements.
     #
@@ -5566,7 +5349,7 @@ module Writexlsx
       attributes << 'pageOrder' << "overThenDown" if print_across?
 
       # Set page orientation.
-      if orientation?
+      if @print_style.orientation?
         attributes << 'orientation' << 'portrait'
       else
         attributes << 'orientation' << 'landscape'
@@ -6000,7 +5783,7 @@ module Writexlsx
     # Write the <legacyDrawing> element.
     #
     def write_legacy_drawing #:nodoc:
-      return unless @has_comments
+      return unless has_comments?
 
       # Increment the relationship id for any drawings or comments.
       id = @hlink_count + 1
@@ -6057,17 +5840,7 @@ module Writexlsx
     # Write the underline font element.
     #
     def write_underline(writer, underline) #:nodoc:
-      # Handle the underline variants.
-      if underline == 2
-        attributes = [val, 'double']
-      elsif underline == 33
-        attributes = [val, 'singleAccounting']
-      elsif underline == 34
-        attributes = [val, 'doubleAccounting']
-      else
-        attributes = []    # Default to single underline.
-      end
-
+      attributes = underline_attributes(underline)
       writer.empty_tag('u', attributes)
     end
 
@@ -6237,12 +6010,13 @@ module Writexlsx
       @writer.end_tag('cfRule')
     end
 
-    def store_data_to_table(row, col, data) #:nodoc:
-      if @table[row]
-        @table[row][col] = data
+    def store_data_to_table(cell_data) #:nodoc:
+      row, col = cell_data.row, cell_data.col
+      if @cell_data_table[row]
+        @cell_data_table[row][col] = cell_data
       else
-        @table[row] = []
-        @table[row][col] = data
+        @cell_data_table[row] = {}
+        @cell_data_table[row][col] = cell_data
       end
     end
 
@@ -6273,7 +6047,7 @@ module Writexlsx
     end
 
     def check_dimensions(row, col)
-      if !row || row >= @xls_rowmax || !col || col >= @xls_colmax
+      if !row || row >= ROW_MAX || !col || col >= COL_MAX
         raise WriteXLSXDimensionError
       end
       0
@@ -6288,7 +6062,7 @@ module Writexlsx
       @dim_rowmin = row if !@dim_rowmin || (row < @dim_rowmin)
       @dim_rowmax = row if !@dim_rowmax || (row > @dim_rowmax)
     end
-    
+
     def store_col_max_min_values(col)
       @dim_colmin = col if !@dim_colmin || (col < @dim_colmin)
       @dim_colmax = col if !@dim_colmax || (col > @dim_colmax)
@@ -6306,11 +6080,9 @@ module Writexlsx
       span_max = 0
       spans = []
       (@dim_rowmin .. @dim_rowmax).each do |row_num|
-        row_ref = @table[row_num]
-        if row_ref
+        if @cell_data_table[row_num]
           (@dim_colmin .. @dim_colmax).each do |col_num|
-            col_ref = @table[row_num][col_num]
-            if col_ref
+            if @cell_data_table[row_num][col_num]
               if !span_min
                 span_min = col_num
                 span_max = col_num
@@ -6370,11 +6142,11 @@ module Writexlsx
       row_char_2 = "$#{row_num_2 + 1}"
 
       # We need to handle some special cases that refer to rows or columns only.
-      if row_num_1 == 0 and row_num_2 == @xls_rowmax - 1
+      if row_num_1 == 0 and row_num_2 == ROW_MAX - 1
         range1       = col_char_1
         range2       = col_char_2
         row_col_only = true
-      elsif col_num_1 == 0 and col_num_2 == @xls_colmax - 1
+      elsif col_num_1 == 0 and col_num_2 == COL_MAX - 1
         range1       = row_char_1
         range2       = row_char_2
         row_col_only = true
@@ -6480,10 +6252,6 @@ module Writexlsx
       @print_style.page_setup_changed
     end
 
-    def orientation? #:nodoc:
-      !!@orientation
-    end
-
     def header_footer_changed? #:nodoc:
       !!@header_footer_changed
     end
@@ -6503,7 +6271,7 @@ module Writexlsx
     def print_across?
       @print_style.across
     end
-    
+
     # List of valid criteria types.
     def valid_criteria_type  # :nodoc:
       {
@@ -6553,7 +6321,7 @@ module Writexlsx
 
         # Convert col ref to a cell ref and then to a col number.
         dummy, col = substitute_cellref("#{col}1")
-        raise "Invalid column '#{col_letter}'" if col >= @xls_colmax
+        raise "Invalid column '#{col_letter}'" if col >= COL_MAX
       end
 
       col_first, col_last = @filter_range