rubyXL 1.2.10 → 2.1.1

data/lib/rubyXL/worksheet.rb

@@ -1,204 +1,168 @@
 module RubyXL
-class Worksheet < PrivateClass
+module LegacyWorksheet
   include Enumerable
 
-  attr_accessor :sheet_name, :sheet_data, :cols, :merged_cells, :pane,
-    :validations, :sheet_view, :legacy_drawing, :extLst, :workbook, :row_styles
-
-  def initialize(workbook, sheet_name='Sheet1',sheet_data=[[nil]],cols=[], merged_cells=[])
-    @workbook = workbook
-
-    @sheet_name = sheet_name
-    @sheet_data = sheet_data
-    @cols = cols
-    @merged_cells = merged_cells
-    @row_styles={}
-    @sheet_view = {
-                    :attributes => {
-                                      :workbookViewId => 0, :zoomScale => 100, :tabSelected => 1, :view=>'normalLayout', :zoomScaleNormal => 100
-                                   }
-                  }
+  attr_accessor :sheet_name, :sheet_id, :validations, :extLst, :workbook
+
+  def initialize(params = {})
+    super
+    @workbook   = params[:workbook]
+    @sheet_name = params[:sheet_name]
+    @sheet_id   = params[:sheet_id]
+    self.sheet_data = RubyXL::SheetData.new
+    self.cols = RubyXL::ColumnRanges.new
     @extLst = nil
-    @legacy_drawing=nil
+    @validations = []
   end
 
   # allows for easier access to sheet_data
-  def [](row=0)
-    return @sheet_data[row]
+  def [](row = 0)
+    sheet_data[row]
   end
 
   def each
-    @sheet_data.each {|i| yield i}
+    sheet_data.rows.each { |row| yield(row) }
   end
 
   #returns 2d array of just the cell values (without style or formula information)
   def extract_data(args = {})
-    raw_values = args.delete(:raw) || false
-    return @sheet_data.map {|row| row.map {|c| if c.is_a?(Cell) then c.value(:raw => raw_values) else nil end}}
+    sheet_data.rows.map { |row| 
+      row && row.cells.map { |c| c && c.value(args) }
+    }
   end
 
-  def get_table(headers=[],opts={})
+  def get_table(headers = [], opts = {})
     validate_workbook
 
-    if !headers.is_a?(Array)
-      headers = [headers]
-    end
-
+    headers = [headers] unless headers.is_a?(Array)
     row_num = find_first_row_with_content(headers)
+    return nil if row_num.nil?
 
-  	if row_num.nil?
-  		return nil
-  	end
-
-  	table_hash = {}
-  	table_hash[:table] = []
+    table_hash = {}
+    table_hash[:table] = []
 
-    header_row = @sheet_data[row_num]
-  	header_row.each_with_index do |header_cell, index|
+    header_row = sheet_data[row_num]
+    header_row.cells.each_with_index { |header_cell, index|
       break if index>0 && !opts[:last_header].nil? && !header_row[index-1].nil? && !header_row[index-1].value.nil? && header_row[index-1].value.to_s==opts[:last_header]
       next if header_cell.nil? || header_cell.value.nil?
       header = header_cell.value.to_s
       table_hash[:sorted_headers]||=[]
       table_hash[:sorted_headers] << header
-  	  table_hash[header] = []
+      table_hash[header] = []
 
-  	  original_row = row_num + 1
-  	  current_row = original_row
+      original_row = row_num + 1
+      current_row = original_row
 
-  	  cell = @sheet_data[current_row][index]
+      row = sheet_data.rows[current_row]
+      cell = row && row.cells[index]
 
       # makes array of hashes in table_hash[:table]
-  	  # as well as hash of arrays in table_hash[header]
+      # as well as hash of arrays in table_hash[header]
       table_index = current_row - original_row
-  	  cell_test= (!cell.nil? && !cell.value.nil?)
-      while cell_test || !table_hash[:table][table_index].empty?
+      cell_test = (!cell.nil? && !cell.value.nil?)
 
-  		  table_hash[header] << (cell_test ? cell.value : nil)
+      while cell_test || (table_hash[:table][table_index] && !table_hash[:table][table_index].empty?)
+        table_hash[header] << cell.value if cell_test
+        table_index = current_row - original_row
 
-    		table_index = current_row - original_row
+        if cell_test then
+          table_hash[:table][table_index] ||= {}
+          table_hash[:table][table_index][header] = cell.value 
+        end
 
-    		if table_hash[:table][table_index].nil?
-    		  table_hash[:table][table_index] = {}
-    		end
+        current_row += 1
+        if sheet_data.rows[current_row].nil? then
+          cell = nil
+        else
+          cell = sheet_data.rows[current_row].cells[index]
+        end
+        cell_test = (!cell.nil? && !cell.value.nil?)
+      end
+    }
 
-    		table_hash[:table][table_index][header] = cell.value if cell_test
+    return table_hash
+  end
 
-    		current_row += 1
-    		if @sheet_data[current_row].nil?
-    		  cell = nil
-  		  else
-      		cell = @sheet_data[current_row][index]
-    		end
-        cell_test= (!cell.nil? && !cell.value.nil?)
-  	  end
-	  end
+  # finds first row which contains at least all strings in cells_content
+  def find_first_row_with_content(cells_content)
+    validate_workbook
+
+    sheet_data.rows.each_with_index { |row, index|
+      next if row.nil?
+      cells_content = cells_content.map { |header| header.to_s.strip.downcase }
+      original_cells_content = row.cells.map { |cell| (cell && cell.value).to_s.strip.downcase }
 
-	  return table_hash
+      if (cells_content & original_cells_content).size == cells_content.size
+        return index
+      end
+    }
+    return nil
   end
+  private :find_first_row_with_content
 
   #changes color of fill in (zer0 indexed) row
-  def change_row_fill(row=0,rgb='ffffff')
+  def change_row_fill(row_index = 0, rgb = 'ffffff')
     validate_workbook
-    validate_nonnegative(row)
-    increase_rows(row)
+    ensure_cell_exists(row_index)
     Color.validate_color(rgb)
-    if @row_styles[(Integer(row)+1).to_s].nil?
-      @row_styles[(Integer(row)+1).to_s] = {}
-      @row_styles[(Integer(row)+1).to_s][:style] = '0'
-    end
-
-    @row_styles[(Integer(row)+1).to_s][:style] = modify_fill(@workbook,Integer(@row_styles[(Integer(row)+1).to_s][:style]),rgb)
 
-    @sheet_data[Integer(row)].each do |c|
-      unless c.nil?
-        c.change_fill(rgb)
-      end
-    end
+    sheet_data.rows[row_index].s = @workbook.modify_fill(get_row_style(row_index), rgb)
+    sheet_data[row_index].cells.each { |c| c.change_fill(rgb) unless c.nil? }
   end
 
-  # Changes font name of row
-  def change_row_font_name(row=0, font_name='Verdana')
-    # Get style object
-    xf_id = xf_id(get_row_style(row))
-    # Get copy of font object with modified name
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font[:name][:attributes][:val] = font_name.to_s
-    # Update font and xf array
-    change_row_font(row, Worksheet::NAME, font_name, font, xf_id)
+  def change_row_font_name(row = 0, font_name = 'Verdana')
+    ensure_cell_exists(row)
+    font = row_font(row).dup
+    font.set_name(font_name)
+    change_row_font(row, Worksheet::NAME, font_name, font)
   end
 
-  # Changes font size of row
-  def change_row_font_size(row=0, font_size=10)
-    # Get style object
-    xf_id = xf_id(get_row_style(row))
-    # Get copy of font object with modified size
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font[:sz][:attributes][:val] = font_size
-    # Update font and xf array
-    change_row_font(row, Worksheet::SIZE, font_size, font, xf_id)
+  def change_row_font_size(row = 0, font_size=10)
+    ensure_cell_exists(row)
+    font = row_font(row).dup
+    font.set_size(font_size)
+    change_row_font(row, Worksheet::SIZE, font_size, font)
   end
 
-  # Changes font color of row
-  def change_row_font_color(row=0, font_color='000000')
+  def change_row_font_color(row = 0, font_color='000000')
+    ensure_cell_exists(row)
     Color.validate_color(font_color)
-    # Get style object
-    xf_id = xf_id(get_row_style(row))
-    # Get copy of font object with modified color
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font = modify_font_color(font, font_color.to_s)
-    # Update font and xf array
-    change_row_font(row, Worksheet::COLOR, font_color, font, xf_id)
-  end
-
-  # Changes font italics settings of row
-  def change_row_italics(row=0, italicized=false)
-    # Get style object
-    xf_id = xf_id(get_row_style(row))
-    # Get copy of font object with modified italics settings
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font = modify_font_italics(font, italicized)
-    # Update font and xf array
-    change_row_font(row, Worksheet::ITALICS, italicized, font, xf_id)
-  end
-
-  # Changes font bold settings of row
-  def change_row_bold(row=0, bolded=false)
-    # Get style object
-    xf_id = xf_id(get_row_style(row))
-    # Get copy of font object with modified bold settings
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font = modify_font_bold(font, bolded)
-    # Update font and xf array
-    change_row_font(row, Worksheet::BOLD, bolded, font, xf_id)
-  end
-
-  # Changes font underline settings of row
-  def change_row_underline(row=0, underlined=false)
-    # Get style object
-    xf_id = xf_id(get_row_style(row))
-    # Get copy of font object with modified underline settings
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font = modify_font_underline(font, underlined)
-    # Update font and xf array
-    change_row_font(row, Worksheet::UNDERLINE, underlined, font, xf_id)
-  end
-
-  # Changes font strikethrough settings of row
-  def change_row_strikethrough(row=0, struckthrough=false)
-    # Get style object
-    xf_id = xf_id(get_row_style(row))
-    # Get copy of font object with modified strikethrough settings
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font = modify_font_strikethrough(font, struckthrough)
-    # Update font and xf array
-    change_row_font(row, Worksheet::STRIKETHROUGH, struckthrough, font, xf_id)
-  end
-
-  def change_row_height(row=0,height=10)
-    validate_workbook
-    validate_nonnegative(row)
+    font = row_font(row).dup
+    font.set_rgb_color(font_color)
+    change_row_font(row, Worksheet::COLOR, font_color, font)
+  end
+
+  def change_row_italics(row = 0, italicized=false)
+    ensure_cell_exists(row)
+    font = row_font(row).dup
+    font.set_italic(italicized)
+    change_row_font(row, Worksheet::ITALICS, italicized, font)
+  end
+
+  def change_row_bold(row = 0, bolded=false)
+    ensure_cell_exists(row)
+    font = row_font(row).dup
+    font.set_bold(bolded)
+    change_row_font(row, Worksheet::BOLD, bolded, font)
+  end
+
+  def change_row_underline(row = 0, underlined=false)
+    ensure_cell_exists(row)
+    font = row_font(row).dup
+    font.set_underline(underlined)
+    change_row_font(row, Worksheet::UNDERLINE, underlined, font)
+  end
 
-    increase_rows(row)
+  def change_row_strikethrough(row = 0, struckthrough=false)
+    ensure_cell_exists(row)
+    font = row_font(row).dup
+    font.set_strikethrough(struckthrough)
+    change_row_font(row, Worksheet::STRIKETHROUGH, struckthrough, font)
+  end
+
+  def change_row_height(row = 0, height=10)
+    validate_workbook
+    ensure_cell_exists(row)
 
     if height.to_i.to_s == height.to_s
       height = Integer(height)
@@ -208,761 +172,449 @@ class Worksheet < PrivateClass
       raise 'You must enter a number for the height'
     end
 
-    if @row_styles[(row+1).to_s].nil?
-      @row_styles[(row+1).to_s] = {}
-      @row_styles[(row+1).to_s][:style] = '0'
-    end
-    @row_styles[(row+1).to_s][:height] = height
-    @row_styles[(row+1).to_s][:customHeight] = '1'
+    sheet_data.rows[row].ht = height
+    sheet_data.rows[row].custom_height = true
   end
 
-  def change_row_horizontal_alignment(row=0,alignment='center')
+  def change_row_horizontal_alignment(row = 0,alignment='center')
     validate_workbook
     validate_nonnegative(row)
-    validate_horizontal_alignment(alignment)
     change_row_alignment(row,alignment,true)
   end
 
-  def change_row_vertical_alignment(row=0,alignment='center')
+  def change_row_vertical_alignment(row = 0,alignment='center')
     validate_workbook
     validate_nonnegative(row)
-    validate_vertical_alignment(alignment)
     change_row_alignment(row,alignment,false)
   end
 
-  def change_row_border_top(row=0,weight='thin')
+  def change_row_border_top(row = 0, weight = 'thin')
     change_row_border(row, :top, weight)
   end
 
-  def change_row_border_left(row=0,weight='thin')
+  def change_row_border_left(row = 0, weight = 'thin')
     change_row_border(row, :left, weight)
   end
 
-  def change_row_border_right(row=0,weight='thin')
+  def change_row_border_right(row = 0, weight = 'thin')
     change_row_border(row, :right, weight)
   end
 
-  def change_row_border_bottom(row=0,weight='thin')
+  def change_row_border_bottom(row = 0, weight = 'thin')
     change_row_border(row, :bottom, weight)
   end
 
-  def change_row_border_diagonal(row=0,weight='thin')
+  def change_row_border_diagonal(row = 0, weight = 'thin')
     change_row_border(row, :diagonal, weight)
   end
 
   # Changes font name of column
-  def change_column_font_name(col=0, font_name='Verdana')
-    # Get style object
-    xf_id = xf_id(get_col_style(col))
-    # Get copy of font object with modified name
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font[:name][:attributes][:val] = font_name.to_s
-    # Update font and xf array
-    change_column_font(col, Worksheet::NAME, font_name, font, xf_id)
+  def change_column_font_name(col = 0, font_name = 'Verdana')
+    xf = get_col_xf(col)
+    font = @workbook.fonts[xf.font_id].dup
+    font.set_name(font_name)
+    change_column_font(col, Worksheet::NAME, font_name, font, xf)
   end
 
   # Changes font size of column
   def change_column_font_size(col=0, font_size=10)
-    # Get style object
-    xf_id = xf_id(get_col_style(col))
-    # Get copy of font object with modified size
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font[:sz][:attributes][:val] = font_size
-    # Update font and xf array
-    change_column_font(col, Worksheet::SIZE, font_size, font, xf_id)
+    xf = get_col_xf(col)
+    font = @workbook.fonts[xf.font_id].dup
+    font.set_size(font_size)
+    change_column_font(col, Worksheet::SIZE, font_size, font, xf)
   end
 
   # Changes font color of column
   def change_column_font_color(col=0, font_color='000000')
     Color.validate_color(font_color)
-    # Get style object
-    xf_id = xf_id(get_col_style(col))
-    # Get copy of font object with modified color
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font = modify_font_color(font, font_color.to_s)
-    # Update font and xf array
-    change_column_font(col, Worksheet::COLOR, font_color, font, xf_id)
-  end
-
-  # Changes font italics settings of column
-  def change_column_italics(col=0, italicized=false)
-    # Get style object
-    xf_id = xf_id(get_col_style(col))
-    # Get copy of font object with modified italics settings
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font = modify_font_italics(font, italicized)
-    # Update font and xf array
-    change_column_font(col, Worksheet::ITALICS, italicized, font, xf_id)
-  end
-
-  # Changes font bold settings of column
-  def change_column_bold(col=0, bolded=false)
-    # Get style object
-    xf_id = xf_id(get_col_style(col))
-    # Get copy of font object with modified bold settings
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font = modify_font_bold(font, bolded)
-    # Update font and xf array
-    change_column_font(col, Worksheet::BOLD, bolded, font, xf_id)
-  end
-
-  # Changes font underline settings of column
-  def change_column_underline(col=0, underlined=false)
-    # Get style object
-    xf_id = xf_id(get_col_style(col))
-    # Get copy of font object with modified underline settings
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font = modify_font_underline(font, underlined)
-    # Update font and xf array
-    change_column_font(col, Worksheet::UNDERLINE, underlined, font, xf_id)
-  end
-
-  # Changes font strikethrough settings of column
-  def change_column_strikethrough(col=0, struckthrough=false)
-    # Get style object
-    xf_id = xf_id(get_col_style(col))
-    # Get copy of font object with modified strikethrough settings
-    font = deep_copy(@workbook.fonts[xf_id[:fontId].to_s][:font])
-    font = modify_font_strikethrough(font, struckthrough)
-    # Update font and xf array
-    change_column_font(col, Worksheet::STRIKETHROUGH, struckthrough, font, xf_id)
+
+    xf = get_col_xf(col)
+    font = @workbook.fonts[xf.font_id].dup
+    font.set_rgb_color(font_color)
+    change_column_font(col, Worksheet::COLOR, font_color, font, xf)
   end
 
-  def change_column_width(col=0,width=13)
-    validate_workbook
-    validate_nonnegative(col)
-    increase_columns(col)
+  def change_column_italics(col = 0, italicized = false)
+    xf = get_col_xf(col)
+    font = @workbook.fonts[xf.font_id].dup
+    font.set_italic(italicized)
+    change_column_font(col, Worksheet::ITALICS, italicized, font, xf)
+  end
 
-    i = get_cols_index(col)
+  def change_column_bold(col = 0, bolded = false)
+    xf = get_col_xf(col)
+    font = @workbook.fonts[xf.font_id].dup
+    font.set_bold(bolded)
+    change_column_font(col, Worksheet::BOLD, bolded, font, xf)
+  end
 
-    if width.to_i.to_s == width.to_s
-      width = Integer(width)
-    elsif width.to_f.to_s == width.to_s
-      width = Float(width)
-    else
-      raise 'You must enter a number for the width'
-    end
+  def change_column_underline(col = 0, underlined = false)
+    xf = get_col_xf(col)
+    font = @workbook.fonts[xf.font_id].dup
+    font.set_underline(underlined)
+    change_column_font(col, Worksheet::UNDERLINE, underlined, font, xf)
+  end
 
-    change_cols(i,col)
-    @cols.last[:attributes][:width] = width
-    @cols.last[:attributes][:customWidth] = '1'
+  def change_column_strikethrough(col=0, struckthrough=false)
+    xf = get_col_xf(col)
+    font = @workbook.fonts[xf.font_id].dup
+    font.set_strikethrough(struckthrough)
+    change_column_font(col, Worksheet::STRIKETHROUGH, struckthrough, font, xf)
   end
 
-  def change_column_fill(col=0, color_index='ffffff')
+  def change_column_width(column_index = 0, width = 13)
     validate_workbook
-    validate_nonnegative(col)
-    Color.validate_color(color_index)
-    increase_columns(col)
-
-    i = get_cols_index(col)
+    ensure_cell_exists(0, column_index)
 
-    if cols[i].nil?
-      style_index = 0
-    else
-      #just copies any style if there is none which already exists for this col
-      #while it changes style/min/max, width *might* be preserved
-      style_index = Integer(@cols[i][:attributes][:style])
-    end
-
-    modify_fill(@workbook,style_index,color_index)
+    range = cols.get_range(column_index)
+    range.width = width
+    range.custom_width = true
+  end
 
-    change_cols(i,col)
+  def change_column_fill(column_index = 0, color_index='ffffff')
+    validate_workbook
+    Color.validate_color(color_index)
+    ensure_cell_exists(0, column_index)
 
-    @sheet_data.each_with_index do |row,i|
-      c = row[Integer(col)]
-      unless c.nil?
-        c.change_fill(color_index)
-      end
-    end
+    cols.get_range(column_index).style = @workbook.modify_fill(get_col_style(column_index), color_index)
 
+    sheet_data.rows.each { |row|
+      c = row[column_index]
+      c.change_fill(color_index) if c
+    }
   end
 
   def change_column_horizontal_alignment(col=0,alignment='center')
-    validate_workbook
-    validate_nonnegative(col)
-    validate_horizontal_alignment(alignment)
     change_column_alignment(col,alignment,true)
   end
 
   def change_column_vertical_alignment(col=0,alignment='center')
-    validate_workbook
-    validate_nonnegative(col)
-    validate_vertical_alignment(alignment)
-    change_column_alignment(col,alignment,false)
+    change_column_alignment(col, alignment, false)
   end
 
-  def change_column_border_top(col=0,weight='thin')
-    change_column_border(col,:top,weight)
+  def change_column_border_top(col=0,weight = 'thin')
+    change_column_border(col, :top, weight)
   end
 
-  def change_column_border_left(col=0,weight='thin')
-    change_column_border(col,:left,weight)
+  def change_column_border_left(col=0,weight = 'thin')
+    change_column_border(col, :left, weight)
   end
 
-  def change_column_border_right(col=0,weight='thin')
-    change_column_border(col,:right,weight)
+  def change_column_border_right(col=0,weight = 'thin')
+    change_column_border(col, :right, weight)
   end
 
-  def change_column_border_bottom(col=0,weight='thin')
-    change_column_border(col,:bottom,weight)
+  def change_column_border_bottom(col=0,weight = 'thin')
+    change_column_border(col, :bottom, weight)
   end
 
-  def change_column_border_diagonal(col=0,weight='thin')
-    change_column_border(col,:diagonal,weight)
+  def change_column_border_diagonal(col=0,weight = 'thin')
+    change_column_border(col, :diagonal, weight)
   end
 
   # merges cells within a rectangular range
-  def merge_cells(row1=0,col1=0,row2=0,col2=0)
-    validate_workbook
-    @merged_cells << {
-      :attributes => {
-        :ref => ''
-      }
-    }
-    cell1 = Cell.convert_to_cell(row1,col1)
-    cell2 = Cell.convert_to_cell(row2,col2)
-    @merged_cells.last[:attributes][:ref] = cell1+':'+cell2
-  end
-
-  def add_cell(row=0, column=0, data='', formula=nil,overwrite=true)
+  def merge_cells(row1 = 0, col1 = 0, row2 = 0, col2 = 0)
     validate_workbook
-    validate_nonnegative(row)
-    validate_nonnegative(column)
-
-    unless @sheet_data.size > row && @sheet_data[row].size > column
-      increase_columns(column)
-      increase_rows(row)
-    end
-
-    datatype = 'str'
-    unless formula.nil?
-      datatype = ''
-    end
-    if overwrite || @sheet_data[row][column].nil?
-      @sheet_data[row][column] = Cell.new(self,row,column,data,formula,datatype)
-
-      if (data.is_a?Integer) || (data.is_a?Float)
-        @sheet_data[row][column].datatype = ''
-      end
-      col = @cols[get_cols_index(column)]
-
-      if @row_styles[(row+1).to_s] != nil
-        @sheet_data[row][column].style_index = @row_styles[(row+1).to_s][:style]
-      elsif col != nil
-        @sheet_data[row][column].style_index = col[:attributes][:style]
-      end
-    end
 
-    add_cell_style(row,column)
+    self.merged_cells_list ||= RubyXL::MergedCells.new
+    merged_cells_list.merge_cell << RubyXL::MergedCell.new(:ref => RubyXL::Reference.new(row1, row2, col1, col2))
+  end
 
-    return @sheet_data[row][column]
+  def add_row(row = 0, params = {})
+    new_row = RubyXL::Row.new(params)
+    new_row.worksheet = self
+    sheet_data.rows[row] = new_row
   end
 
-  def add_cell_obj(cell, overwrite=true)
+  def add_cell(row = 0, column = 0, data = '', formula = nil, overwrite = true)
     validate_workbook
+    ensure_cell_exists(row, column)
 
-    if cell.nil?
-      return cell
-    end
-
-    row = cell.row
-    column = cell.column
+    if overwrite || sheet_data.rows[row].cells[column].nil?
+      c = RubyXL::Cell.new
+      c.worksheet = self
+      c.row = row
+      c.column = column
+      c.raw_value = data
+      c.datatype = (formula || data.is_a?(Numeric)) ? '' : RubyXL::Cell::RAW_STRING
+      c.formula = formula
 
-    validate_nonnegative(row)
-    validate_nonnegative(column)
+      range = cols && cols.find(column)
+      c.style_index = sheet_data.rows[row].s || (range && range.style_index) || 0
 
-    unless @sheet_data.size > row && @sheet_data[row].size > column
-      increase_columns(column)
-      increase_rows(row)
-    end
-    if overwrite || @sheet_data[row][column].nil?
-      @sheet_data[row][column] = cell
+      sheet_data.rows[row].cells[column] = c
     end
 
-    add_cell_style(row,column)
+    add_cell_style(row, column)
 
-    return @sheet_data[row][column]
+    sheet_data.rows[row].cells[column]
   end
 
   def delete_row(row_index=0)
     validate_workbook
     validate_nonnegative(row_index)
+    return nil unless row_exists(row_index)
 
-    if row_index >= @sheet_data.size
-      return nil
-    end
-
-    deleted = @sheet_data.delete_at(row_index)
+    deleted = sheet_data.rows.delete_at(row_index)
     row_num = row_index+1
 
-    row_num.upto(@sheet_data.size) do |index|
-      @row_styles[(index-1).to_s] = deep_copy(@row_styles[index.to_s])
-    end
-    @row_styles.delete(@sheet_data.size.to_s)
-
-    #change row styles
-    # raise row_styles.inspect
-
-    #change cell row numbers
-    (row_index...(@sheet_data.size-1)).each do |index|
-      @sheet_data[index].map {|c| c.row -= 1 if c}
-    end
+    # Change cell row numbers
+    row_index.upto(sheet_data.size - 1) { |index|
+      sheet_data[index].cells.each{ |c| c.row -= 1 unless c.nil? }
+    }
 
     return deleted
   end
 
-  #inserts row at row_index, pushes down, copies style from below (row previously at that index)
+  # Inserts row at row_index, pushes down, copies style from the row above (that's what Excel 2013 does!)
   #USE OF THIS METHOD will break formulas which reference cells which are being "pushed down"
-  def insert_row(row_index=0)
+  def insert_row(row_index = 0)
     validate_workbook
-    validate_nonnegative(row_index)
-
-    increase_rows(row_index)
-
-    @sheet_data.insert(row_index,Array.new(@sheet_data[row_index].size))
-
-    row_num = row_index+1
-
-    #copy cell styles from row above, (or below if first row)
-    @sheet_data[row_index].each_index do |i|
-      if row_index > 0
-        old_cell = @sheet_data[row_index-1][i]
-      else
-        old_cell = @sheet_data[row_index+1][i]
-      end
-
-      unless old_cell.nil?
-        #only add cell if style exists, not copying content
+    ensure_cell_exists(row_index)
 
-        if @row_styles[(row_num+1).to_s].nil?
-          @row_styles[(row_num+1).to_s] = {:style=>0}
-        end
-        if old_cell.style_index != 0 && old_cell.style_index.to_s != @row_styles[(row_num+1).to_s][:style].to_s
-          c = Cell.new(self,row_index,i)
-          c.style_index = old_cell.style_index
-          @sheet_data[row_index][i] = c
-        end
-      end
-    end
-
-    #copy row styles from row above, (or below if first row)
-    (@row_styles.size+1).downto(row_num+1) do |i|
-      @row_styles[i.to_s] = @row_styles[(i-1).to_s]
-    end
-    if row_index > 0
-      @row_styles[row_num.to_s] = @row_styles[(row_num-1).to_s]
+    if row_index == 0 then
+      old_row = nil
+      new_cells = Array.new(sheet_data.rows[0].cells.size)
     else
-      @row_styles[row_num.to_s] = nil#@row_styles[(row_num+1).to_s]
+      old_row = sheet_data.rows[row_index - 1] 
+      new_cells = old_row.cells.collect { |c| 
+                                          if c.nil? then nil
+                                          else RubyXL::Cell.new(:style_index => c.style_index)
+                                          end }
     end
 
+    sheet_data.rows.insert(row_index, nil)
+    new_row = add_row(row_index, :cells => new_cells, :s => old_row && old_row.s)
+
     #update row value for all rows below
-    (row_index+1).upto(@sheet_data.size-1) do |i|
-      row = @sheet_data[i]
-      row.each do |c|
-        unless c.nil?
-          c.row += 1
-        end
-      end
-    end
+    row_index.upto(sheet_data.rows.size - 1) { |i|
+      row = sheet_data.rows[i]
+      row.cells.each { |c| c.row = i unless c.nil? }
+    }
 
-    return @sheet_data[row_index]
+    return new_row
   end
 
-  def delete_column(col_index=0)
+  def delete_column(column_index = 0)
     validate_workbook
-    validate_nonnegative(col_index)
+    validate_nonnegative(column_index)
 
-    if col_index >= @sheet_data[0].size
-      return nil
-    end
+    return nil unless column_exists(column_index)
 
     #delete column
-    @sheet_data.map {|r| r.delete_at(col_index)}
+    sheet_data.rows.each { |row| row.cells.delete_at(column_index) }
 
     #change column numbers for cells to right of deleted column
-    @sheet_data.each_with_index do |row,row_index|
-      (col_index...(row.size)).each do |index|
-        if @sheet_data[row_index][index].is_a?(Cell)
-          @sheet_data[row_index][index].column -= 1
-        end
-      end
-    end
+    sheet_data.rows.each_with_index { |row, row_index|
+      row.cells.each_with_index { |c, column_index|
+        c.column -= 1 if c.is_a?(Cell)
+      }
+    }
 
-    #shift column styles
-    #shift col styles 'left'
-    @cols.each do |col|
-      if Integer(col[:attributes][:min]) >= col_index
-        col[:attributes][:min] = (Integer(col[:attributes][:min]) - 1).to_s
-      end
-      if Integer(col[:attributes][:max]) >= col_index
-        col[:attributes][:max] = (Integer(col[:attributes][:max]) - 1).to_s
-      end
-    end
+    cols.column_ranges.each { |range| range.delete_column(column_index) }
   end
 
-  # inserts column at col_index, pushes everything right, takes styles from column to left
+  # inserts column at +column_index+, pushes everything right, takes styles from column to left
   # USE OF THIS METHOD will break formulas which reference cells which are being "pushed down"
-  def insert_column(col_index=0)
+  def insert_column(column_index = 0)
     validate_workbook
-    validate_nonnegative(col_index)
-    increase_columns(col_index)
+    ensure_cell_exists(0, column_index)
 
-    old_index = col_index > 0 ? col_index-1 : col_index+1
-    old_col = @cols[get_cols_index(old_index)]
-    if old_index == 1
-      old_col = nil
-    end
+    old_range = cols.get_range(column_index)
 
     #go through each cell in column
-    @sheet_data.each_with_index do |r,i|
-      #insert "column" in each row
-      r.insert(col_index, nil)
-
-      #copy styles over to each cell
-      old_cell = r[old_index]
-      unless old_cell.nil?
-        #only add cell if style exists, not copying content
-        if old_cell.style_index != 0
-          if !old_col.nil? && old_cell.style_index.to_s != old_col[:attributes][:style].to_s
-            c = Cell.new(self,i,col_index)
-            c.style_index = old_cell.style_index
-            @sheet_data[i][col_index] = c
-          end
-        end
+    sheet_data.rows.each_with_index { |row, row_index|
+      old_cell = row[column_index]
+      c = nil
+
+      if old_cell && old_cell.style_index != 0 &&
+           old_range && old_range.style != old_cell.style_index then
+
+        c = Cell.new
+        c.worksheet = self
+        c.row = row_index
+        c.column = column_index
+        c.datatype = RubyXL::Cell::SHARED_STRING
+        c.style_index = old_cell.style_index
       end
-    end
 
-    #copy over column-level styles
-    new_col = change_cols(get_cols_index(old_index),old_index)
-    @cols[-1] = deep_copy(old_col)#-1 = last
+      row.insert_cell_shift_right(c, column_index)
+    }
 
-    new_col = @cols.last
-    if @cols.last.nil?
-      @cols.pop
-    end
+    cols.insert_column(column_index)
 
-    #shift col styles 'right'
-    @cols.each do |col|
-      if Integer(col[:attributes][:min]) > col_index
-        col[:attributes][:min] = (1 + Integer(col[:attributes][:min])).to_s
-      end
-      if Integer(col[:attributes][:max]) > col_index
-        col[:attributes][:max] = (1 + Integer(col[:attributes][:max])).to_s
-      end
-    end
-    unless new_col.nil?
-      new_col[:attributes][:min] = (1 + Integer(new_col[:attributes][:min])).to_s
-      new_col[:attributes][:max] = (1 + Integer(new_col[:attributes][:max])).to_s
-    end
-
-    #update column numbers
-    @sheet_data.each do |row|
-      (col_index+1).upto(row.size) do |j|
-        unless row[j].nil?
-          row[j].column += 1
-        end
-      end
-    end
+    # TODO: update column numbers
   end
 
-  def insert_cell(row=0,col=0,data=nil,formula=nil,shift=nil)
+  def insert_cell(row = 0, col = 0, data = nil, formula = nil, shift = nil)
     validate_workbook
-    validate_nonnegative(row)
-    validate_nonnegative(col)
-
-    increase_rows(row)
-    increase_columns(col)
+    ensure_cell_exists(row, col)
 
-    if shift && shift != :right && shift != :down
+    case shift
+    when nil then # No shifting at all
+    when :right then
+      sheet_data.rows[row].insert_cell_shift_right(nil, col)
+    when :down then
+      add_row(sheet_data.size, :cells => Array.new(sheet_data.rows[row].size))
+      (sheet_data.size - 1).downto(row+1) { |index|
+        sheet_data.rows[index].cells[col] = sheet_data.rows[index-1].cells[col]
+      }
+    else
       raise 'invalid shift option'
     end
 
-    if shift == :right
-      @sheet_data[row].insert(col,nil)
-      (row...(@sheet_data[row].size)).each do |index|
-        if @sheet_data[row][index].is_a?(Cell)
-          @sheet_data[row][index].column += 1
-        end
-      end
-    elsif shift == :down
-      @sheet_data << Array.new(@sheet_data[row].size)
-      (@sheet_data.size-1).downto(row+1) do |index|
-        @sheet_data[index][col] = @sheet_data[index-1][col]
-      end
-    end
-
     return add_cell(row,col,data,formula)
   end
 
   # by default, only sets cell to nil
   # if :left is specified, method will shift row contents to the right of the deleted cell to the left
   # if :up is specified, method will shift column contents below the deleted cell upward
-  def delete_cell(row=0,col=0,shift=nil)
+  def delete_cell(row = 0, col=0, shift=nil)
     validate_workbook
     validate_nonnegative(row)
     validate_nonnegative(col)
-    if @sheet_data.size <= row || @sheet_data[row].size <= col
-      return nil
-    end
 
-    cell = @sheet_data[row][col]
-    @sheet_data[row][col]=nil
+    return nil unless row_exists(row) && column_exists(col)
 
-    if shift && shift != :left && shift != :up
-      raise 'invalid shift option'
-    end
+    cell = sheet_data[row][col]
 
-    if shift == :left
-      @sheet_data[row].delete_at(col)
-      @sheet_data[row] << nil
-      (col...(@sheet_data[row].size)).each do |index|
-        if @sheet_data[row][index].is_a?(Cell)
-          @sheet_data[row][index].column -= 1
-        end
-      end
-    elsif shift == :up
-      (row...(@sheet_data.size-1)).each do |index|
-        @sheet_data[index][col] = @sheet_data[index+1][col]
-        if @sheet_data[index][col].is_a?(Cell)
-          @sheet_data[index][col].row -= 1
-        end
-      end
-      if @sheet_data.last[col].is_a?(Cell)
-        @sheet_data.last[col].row -= 1
-      end
+    case shift
+    when nil then
+      sheet_data.rows[row].cells[col] = nil
+    when :left then
+      sheet_data.rows[row].delete_cell_shift_left(col)
+    when :up then
+      (row...(sheet_data.size - 1)).each { |index|
+        c = sheet_data.rows[index].cells[col] = sheet_data.rows[index + 1].cells[col]
+        c.row -= 1 if c.is_a?(Cell)
+      }
+    else
+      raise 'invalid shift option'
     end
 
     return cell
   end
 
-  def get_row_fill(row=0)
-    validate_workbook
-    validate_nonnegative(row)
-
-    if @sheet_data.size <= row
-      return nil
-    end
-
-    if @row_styles[(row+1).to_s].nil?
-      return "ffffff" #default, white
-    end
-
-    xf = xf_attr_row(row)
-
-    return @workbook.get_fill_color(xf)
+  def get_row_fill(row = 0)
+    (row = sheet_data.rows[row]) && row.get_fill_color
   end
 
-  def get_row_font_name(row=0)
-    validate_workbook
-    validate_nonnegative(row)
-
-    if @sheet_data.size <= row
-      return nil
-    end
-
-    if @row_styles[(row+1).to_s].nil?
-      return 'Verdana'
-    end
-
-    xf = xf_attr_row(row)
-
-    return @workbook.fonts[xf[:fontId].to_s][:font][:name][:attributes][:val]
+  def get_row_font_name(row = 0)
+    (font = row_font(row)) && font.get_name
   end
 
-  def get_row_font_size(row=0)
-    validate_workbook
-    validate_nonnegative(row)
-
-    if @sheet_data.size <= row
-      return nil
-    end
-
-    if @row_styles[(row+1).to_s].nil?
-      return '10'
-    end
-
-    xf = xf_attr_row(row)
-
-    return @workbook.fonts[xf[:fontId].to_s][:font][:sz][:attributes][:val]
+  def get_row_font_size(row = 0)
+    (font = row_font(row)) && font.get_size
   end
 
-  def get_row_font_color(row=0)
-    validate_workbook
-    validate_nonnegative(row)
-
-    if @sheet_data.size <= row
-      return nil
-    end
-
-    if @row_styles[(row+1).to_s].nil?
-      return '000000'
-    end
-
-    xf = xf_attr_row(row)
-
-    color = @workbook.fonts[xf[:fontId].to_s][:font][:color]
-
-    if color.nil? || color[:attributes].nil? || color[:attributes][:rgb].nil?
-      return '000000'
-    end
-
-    return color[:attributes][:rgb]
+  def get_row_font_color(row = 0)
+    font = row_font(row)
+    color = font && font.color
+    color && (color.rgb || '000000')
   end
 
-  def is_row_italicized(row=0)
-    return get_row_bool(row,:i)
+  def is_row_italicized(row = 0)
+    (font = row_font(row)) && font.is_italic
   end
 
-  def is_row_bolded(row=0)
-    return get_row_bool(row,:b)
+  def is_row_bolded(row = 0)
+    (font = row_font(row)) && font.is_bold
   end
 
-  def is_row_underlined(row=0)
-    return get_row_bool(row,:u)
+  def is_row_underlined(row = 0)
+    (font = row_font(row)) && font.is_underlined
   end
 
-  def is_row_struckthrough(row=0)
-    return get_row_bool(row,:strike)
+  def is_row_struckthrough(row = 0)
+    (font = row_font(row)) && font.is_strikethrough
   end
 
-
-  def get_row_height(row=0)
+  def get_row_height(row = 0)
     validate_workbook
     validate_nonnegative(row)
-
-    if @sheet_data.size <= row
-      return nil
-    end
-
-    if @row_styles[(row+1).to_s].nil?
-      return 13
-    else
-      @row_styles[(row+1).to_s][:height]
-    end
+    return nil unless row_exists(row)
+    row = sheet_data.rows[row]
+    row && row.ht || 13
   end
 
-  def get_row_horizontal_alignment(row=0)
-    return get_row_alignment(row,true)
+  def get_row_horizontal_alignment(row = 0)
+    return get_row_alignment(row, true)
   end
 
-  def get_row_vertical_alignment(row=0)
-    return get_row_alignment(row,false)
+  def get_row_vertical_alignment(row = 0)
+    return get_row_alignment(row, false)
   end
 
-  def get_row_border_top(row=0)
-    return get_row_border(row,:top)
+  def get_row_border_top(row = 0)
+    return get_row_border(row, :top)
   end
 
-  def get_row_border_left(row=0)
-    return get_row_border(row,:left)
-  end
+  def get_row_border_left(row = 0)
+    return get_row_border(row, :left)
+  end                         
 
-  def get_row_border_right(row=0)
-    return get_row_border(row,:right)
+  def get_row_border_right(row = 0)
+    return get_row_border(row, :right)
   end
 
-  def get_row_border_bottom(row=0)
-    return get_row_border(row,:bottom)
+  def get_row_border_bottom(row = 0)
+    return get_row_border(row, :bottom)
   end
 
-  def get_row_border_diagonal(row=0)
-    return get_row_border(row,:diagonal)
+  def get_row_border_diagonal(row = 0)
+    return get_row_border(row, :diagonal)
   end
 
-  def get_column_font_name(col=0)
-    validate_workbook
-    validate_nonnegative(col)
-
-    if @sheet_data[0].size <= col
-      return nil
-    end
-
-    style_index = get_cols_style_index(col)
-
-    return @workbook.fonts[font_id( style_index ).to_s][:font][:name][:attributes][:val]
+  def get_column_font_name(col = 0)
+    font = column_font(col)
+    font && font.get_name
   end
 
-  def get_column_font_size(col=0)
-    validate_workbook
-    validate_nonnegative(col)
-
-    if @sheet_data[0].size <= col
-      return nil
-    end
-
-    style_index = get_cols_style_index(col)
-
-    return @workbook.fonts[font_id( style_index ).to_s][:font][:sz][:attributes][:val]
+  def get_column_font_size(col = 0)
+    font = column_font(col)
+    font && font.get_size
   end
 
-  def get_column_font_color(col=0)
-    validate_workbook
-    validate_nonnegative(col)
-
-    if @sheet_data[0].size <= col
-      return nil
-    end
-
-    style_index = get_cols_style_index(col)
-
-    font = @workbook.fonts[font_id( style_index ).to_s][:font]
-
-    if font[:color].nil? || font[:color][:attributes].nil? || font[:color][:attributes][:rgb].nil?
-      return '000000'
-    end
-
-    return font[:color][:attributes][:rgb]
-
+  def get_column_font_color(col = 0)
+    font = column_font(col)
+    font && (font.get_rgb_color || '000000')
   end
 
-  def is_column_italicized(col=0)
-    get_column_bool(col,:i)
+  def is_column_italicized(col = 0)
+    font = column_font(col)
+    font && font.is_italic
   end
 
-  def is_column_bolded(col=0)
-    get_column_bool(col,:b)
+  def is_column_bolded(col = 0)
+    font = column_font(col)
+    font && font.is_bold
   end
 
-  def is_column_underlined(col=0)
-    get_column_bool(col,:u)
+  def is_column_underlined(col = 0)
+    font = column_font(col)
+    font && font.is_underlined
   end
 
-  def is_column_struckthrough(col=0)
-    get_column_bool(col,:strike)
+  def is_column_struckthrough(col = 0)
+    font = column_font(col)
+    font && font.is_strikethrough
   end
 
-  def get_column_width(col=0)
+  def get_column_width(column_index = 0)
     validate_workbook
-    validate_nonnegative(col)
-
-    if @sheet_data[0].size <= col
-      return nil
-    end
-
-    cols_index = get_cols_index(col)
+    validate_nonnegative(column_index)
+    return nil unless column_exists(column_index)
 
-    if @cols[cols_index].nil? || @cols[cols_index][:attributes].nil? || @cols[cols_index][:attributes][:width].to_s == ''
-      return 10
-    end
-
-    return @cols[cols_index][:attributes][:width]
+    range = cols.find(column_index)
+    (range && range.width) || 10
   end
 
   def get_column_fill(col=0)
     validate_workbook
     validate_nonnegative(col)
+    return nil unless column_exists(col)
 
-    if @sheet_data[0].size <= col
-      return nil
-    end
-
-    style_index = get_cols_style_index(col)
-
-    if style_index == 0
-      return "ffffff" #default, white
-    end
-
-    return @workbook.get_fill_color(@workbook.cell_xfs[:xf][style_index][:attributes])
+    @workbook.get_fill_color(get_col_xf(col))
   end
 
   def get_column_horizontal_alignment(col=0)
@@ -974,269 +626,132 @@ class Worksheet < PrivateClass
   end
 
   def get_column_border_top(col=0)
-    return get_column_border(col,:top)
+    get_column_border(col, :top)
   end
 
   def get_column_border_left(col=0)
-    return get_column_border(col,:left)
+    get_column_border(col, :left)
   end
 
   def get_column_border_right(col=0)
-    return get_column_border(col,:right)
+    get_column_border(col, :right)
   end
 
   def get_column_border_bottom(col=0)
-    return get_column_border(col,:bottom)
+    get_column_border(col, :bottom)
   end
 
   def get_column_border_diagonal(col=0)
-    return get_column_border(col,:diagonal)
+    get_column_border(col, :diagonal)
   end
 
 
   private
 
-  Worksheet::NAME = 0
-  Worksheet::SIZE = 1
-  Worksheet::COLOR = 2
-  Worksheet::ITALICS = 3
-  Worksheet::BOLD = 4
-  Worksheet::UNDERLINE = 5
-  Worksheet::STRIKETHROUGH = 6
-
-  #row_styles is assumed to not be nil at specified row
-  def xf_attr_row(row)
-    row_style = @row_styles[(row+1).to_s][:style]
-    return @workbook.get_style_attributes(@workbook.get_style(row_style))
-  end
-
-  def xf_attr_col(column)
-    col_style = @cols[get_cols_index(column)][:style]
-	return @workbook.get_style_attributes(@workbook.get_style(Integer(col_style)))
-  end
-
-  def get_row_bool(row,property)
-    validate_workbook
-    validate_nonnegative(row)
-
-    if @sheet_data.size <= row
-      return nil
-    end
+  NAME = 0
+  SIZE = 1
+  COLOR = 2
+  ITALICS = 3
+  BOLD = 4
+  UNDERLINE = 5
+  STRIKETHROUGH = 6
 
-    if @row_styles[(row+1).to_s].nil?
-      return false
-    end
-
-    xf = xf_attr_row(row)
-
-    return !@workbook.fonts[xf[:fontId].to_s][:font][property].nil?
+  def row_font(row)
+    (row = sheet_data.rows[row]) && row.get_font
   end
 
-  def get_row_alignment(row,is_horizontal)
+  def get_row_alignment(row, is_horizontal)
     validate_workbook
     validate_nonnegative(row)
 
-    if @sheet_data.size <= row || @row_styles[(row+1).to_s].nil?
-      return nil
-    end
+    return nil unless row_exists(row)
 
-    xf_obj = @workbook.get_style(@row_styles[(row+1).to_s][:style])
-
-    if xf_obj[:alignment].nil? || xf_obj[:alignment][:attributes].nil?
-      return nil
-    end
+    xf_obj = get_row_xf(row)
+    return nil if xf_obj.alignment.nil?
 
-    if is_horizontal
-      return xf_obj[:alignment][:attributes][:horizontal].to_s
-    else
-      return xf_obj[:alignment][:attributes][:vertical].to_s
+    if is_horizontal then return xf_obj.alignment.horizontal
+    else                  return xf_obj.alignment.vertical
     end
   end
 
-  def get_row_border(row,border_direction)
+  def get_row_border(row, border_direction)
     validate_workbook
     validate_nonnegative(row)
 
-    if @sheet_data.size <= row || @row_styles[(row+1).to_s].nil?
-      return nil
-    end
-
-    if @workbook.borders[xf_attr_row(row)[:borderId]].nil? && !@workbook.borders[xf_attr_row(row)[:borderId].to_s].nil?
-      @workbook.borders[xf_attr_row(row)[:borderId]] = deep_copy(@workbook.borders[xf_attr_row(row)[:borderId].to_s])
-      @workbook.borders.delete(xf_attr_row(row)[:borderId].to_s)
-    end
-
-    if @workbook.borders[xf_attr_row(row)[:borderId]][:border][border_direction][:attributes].nil?
-      return nil
-    end
+    return nil unless row_exists(row)
 
-    return @workbook.borders[xf_attr_row(row)[:borderId]][:border][border_direction][:attributes][:style]
+    border = @workbook.borders[get_row_xf(row).border_id]
+    border && border.get_edge_style(border_direction)
   end
 
-  def get_column_bool(col,property)
+  def column_font(col)
     validate_workbook
     validate_nonnegative(col)
+    return nil unless column_exists(col)
 
-    if @sheet_data[0].size <= col
-      return nil
-    end
-
-    style_index = get_cols_style_index(col)
-
-    return !@workbook.fonts[font_id( style_index ).to_s][:font][property].nil?
+    @workbook.fonts[@workbook.cell_xfs[get_cols_style_index(col)].font_id]
   end
 
   def get_column_alignment(col, type)
     validate_workbook
     validate_nonnegative(col)
+    return nil unless column_exists(col)
 
-    if @sheet_data[0].size <= col
-      return nil
-    end
-
-    style_index = get_cols_style_index(col)
-
-    xf_obj = @workbook.get_style(style_index)
-    if xf_obj[:alignment].nil?
-      return nil
-    end
-
-    return xf_obj[:alignment][:attributes][type]
+    xf = @workbook.cell_xfs[get_cols_style_index(col)]
+    xf.alignment && xf.alignment.send(type)
   end
 
   def get_column_border(col, border_direction)
     validate_workbook
     validate_nonnegative(col)
-    style_index = get_cols_style_index(col)
-    xf = @workbook.get_style_attributes(@workbook.get_style(style_index))
-
-    if @sheet_data[0].size <= col
-      return nil
-    end
-
-    if @workbook.borders[xf[:borderId]].nil? && !@workbook.borders[xf[:borderId].to_s].nil?
-      @workbook.borders[xf[:borderId]] = deep_copy(@workbook.borders[xf[:borderId].to_s])
-      @workbook.borders.delete(xf[:borderId].to_s)
-    end
-
-    if @workbook.borders[xf[:borderId]][:border][border_direction][:attributes].nil?
-      return nil
-    end
-
-    return @workbook.borders[xf[:borderId]][:border][border_direction][:attributes][:style]
-  end
+    return nil unless column_exists(col)
 
-  def deep_copy(hash)
-    Marshal.load(Marshal.dump(hash))
+    xf = @workbook.cell_xfs[get_cols_style_index(col)]
+    border = @workbook.borders[xf.border_id]
+    border && border.get_edge_style(border_direction)
   end
 
   #validates Workbook, ensures that this worksheet is in @workbook
   def validate_workbook()
     unless @workbook.nil? || @workbook.worksheets.nil?
-      @workbook.worksheets.each do |sheet|
-        if sheet == self
-          return
-        end
-      end
+      return if @workbook.worksheets.include?(self)
     end
-    raise "This worksheet #{self} is not in workbook #{@workbook}"
-  end
-
-  # because cols is not ordered by col num, this actually gets
-  # the index in the array based on which column is actually being asked for by the user
-  def get_cols_index(col)
-    i = @cols.size - 1
-
-    @cols.reverse_each do |column|
-      if col >= (Integer(column[:attributes][:min])-1)
-        if col <= (Integer(column[:attributes][:max])-1)
-          break
-        end
-      end
-      i -= 1
-    end
-    if i < 0
-      i = @cols.size #effectively nil
-    end
-    i
-  end
 
-  def get_cols_style_index(col)
-    cols_index = get_cols_index(col)
-    if cols_index == @cols.size
-      return 0
-    end
-    return Integer(@cols[cols_index][:attributes][:style])
+    raise "This worksheet #{self} is not in workbook #{@workbook}"
   end
 
-  #change cols array
-  def change_cols(i,col_index)
-    style = '0'
-    if @cols[i].nil?
-      @cols << {:attributes=>{:style=>nil,:min=>nil,:max=>nil,:width=>nil,:customWidth=>nil}}
-    else
-      @cols << deep_copy(@cols[i])
-      style = @cols[i][:attributes][:style]
-    end
-    @cols.last[:attributes][:style] = style
-    @cols.last[:attributes][:min] = (Integer(col_index)+1).to_s
-    @cols.last[:attributes][:max] = (Integer(col_index)+1).to_s
-    @cols.last[:attributes][:width] = '10'
-    @cols.last[:attributes][:customWidth] = '0'
+  def get_cols_style_index(column_index)
+    range = cols.find(column_index)
+    (range && range.style) || 0
   end
 
   # Helper method to update the row styles array
   # change_type - NAME or SIZE or COLOR etc
   # main method to change font, called from each separate font mutator method
-  def change_row_font(row, change_type, arg, font, xf_id)
+  def change_row_font(row, change_type, arg, font)
     validate_workbook
-    validate_nonnegative(row)
-    increase_rows(row)
-
-    # Modify font array and retrieve new font id
-    font_id = modify_font(@workbook, font, xf_id[:fontId].to_s)
-    # Get copy of xf object with modified font id
-    xf = deep_copy(xf_id)
-    xf[:fontId] = Integer(font_id)
-    # Modify xf array and retrieve new xf id
-    @row_styles[(row+1).to_s][:style] = modify_xf(@workbook, xf)
-
-    if @sheet_data[row].nil?
-      @sheet_data[row] = []
-    end
+    ensure_cell_exists(row)
 
-    @sheet_data[Integer(row)].each do |c|
-      unless c.nil?
-        font_switch(c, change_type, arg)
-      end
-    end
+    xf = workbook.register_new_font(font, get_row_xf(row))
+    sheet_data.rows[row].s = workbook.register_new_xf(xf, get_row_style(row))
+
+    sheet_data[row].cells.each { |c| font_switch(c, change_type, arg) unless c.nil? }
   end
 
   # Helper method to update the fonts and cell styles array
   # main method to change font, called from each separate font mutator method
-  def change_column_font(col, change_type, arg, font, xf_id)
+  def change_column_font(column_index, change_type, arg, font, xf)
     validate_workbook
-    validate_nonnegative(col)
-    increase_columns(col)
-
-    i = get_cols_index(col)
+    ensure_cell_exists(0, column_index)
 
-    # Modify font array and retrieve new font id
-    font_id = modify_font(@workbook, font, xf_id[:fontId].to_s)
-    # Get copy of xf object with modified font id
-    xf = deep_copy(xf_id)
-    xf[:fontId] = Integer(font_id)
-    # Modify xf array and retrieve new xf id
-    modify_xf(@workbook, xf)
+    xf = workbook.register_new_font(font, xf)
 
-    change_cols(i, col)
+    cols.get_range(column_index).style = workbook.register_new_xf(xf, get_col_style(column_index))
 
-    @sheet_data.each_with_index do |row, i|
-      c = row[col]
-      unless c.nil?
-        font_switch(c, change_type, arg)
-      end
-    end
+    sheet_data.rows.each { |row|
+      c = row[column_index]
+      font_switch(c, change_type, arg) unless c.nil?
+    }
   end
 
   #performs correct modification based on what type of change_type is specified
@@ -1280,214 +795,146 @@ class Worksheet < PrivateClass
     end
   end
 
-  #increases number of rows until the array at index row is not nil
-  def increase_rows(row)
-    @sheet_data.size.upto(row) do
-      @sheet_data << Array.new(@sheet_data[0].size)
-    end
-  end
-
-  #increases number of columns until the array at index column is not nil
-  def increase_columns(column)
-    @sheet_data.each do |r|
-      r.size.upto(column) do
-        r << nil
-      end
-    end
-  end
+  # Ensures that cell with +row_index+ and +column_index+ exists in
+  #  +sheet_data+ arrays, growing them up if necessary.
+  def ensure_cell_exists(row_index, column_index = 0)
+    validate_nonnegative(row_index)
+    validate_nonnegative(column_index)
+
+    existing_row_count = sheet_data.rows.size
+
+    # Expand cell arrays in existing rows, if necessary.
+    # Writing anything to a cell in the array automatically creates all the members
+    # with lower indices, filling them with +nil+s. But, we can't just write +nil+
+    # to +column_index+ because it may be less than +size+! So we read from that index
+    # (if it didn't exist, we will get nil) and write right back.
+    sheet_data.rows.each { |r| r.cells[column_index] = r.cells[column_index] }
+
+    first_row = sheet_data.rows.first
+    col_size = [ first_row && first_row.cells.size || 0, column_index ].max
+
+    # Now create new rows with the required number of cells.
+    # Doing +.downto()+ here so the reallocation of row array has to only happen once,
+    # when it is extended to max size; after that, we will be writing into existing
+    # (but empty) members. Additional checks are not necessary, because if +row_index+
+    # is less than +size+, then +.downto()+ will not execute, and if it equals +size+,
+    # then the block will be invoked exactly once, which takes care of the case when
+    # +row_index+ is greater than the current max index by exactly 1.
+    row_index.downto(existing_row_count) { |r| 
+      add_row(r, :cells => Array.new(col_size))
+    } 
+  end  
 
-  # Helper method to get the font id for a style index
-  def font_id(style_index)
-    xf_id(style_index)[:fontId]
+  # Helper method to get the style index for a column
+  def get_col_style(column_index)
+    range = cols.find(column_index)
+    (range && range.style) || 0
   end
 
-  # Helper method to get the style attributes for a style index
-  def xf_id(style_index)
-    @workbook.get_style_attributes(@workbook.get_style(style_index))
+  def get_row_style(row)
+    r = sheet_data.rows[row]
+    (r && r.s) || 0
   end
 
-  # Helper method to get the style index for a row
-  def get_row_style(row)
-    if @row_styles[(row+1).to_s].nil?
-      @row_styles[(row+1).to_s] = {}
-      @row_styles[(row+1).to_s][:style] = '0'
-      @workbook.fonts['0'][:count] += 1
-    end
-    return @row_styles[(row+1).to_s][:style]
+  def get_col_xf(column_index)
+    @workbook.cell_xfs[get_col_style(column_index)]
   end
 
-  # Helper method to get the style index for a column
-  def get_col_style(col)
-    i = get_cols_index(col)
-    if @cols[i].nil?
-      @workbook.fonts['0'][:count] += 1
-      return 0
-    else
-      return Integer(@cols[i][:attributes][:style])
-    end
+  def get_row_xf(row)
+    @workbook.cell_xfs[get_row_style(row)]
   end
 
   def change_row_alignment(row,alignment,is_horizontal)
     validate_workbook
     validate_nonnegative(row)
+    ensure_cell_exists(row)
 
-    increase_rows(row)
+    sheet_data.rows[row].s = @workbook.modify_alignment(get_row_style(row), is_horizontal, alignment)
 
-    if @row_styles[(row+1).to_s].nil?
-      @row_styles[(row+1).to_s] = {}
-      @row_styles[(row+1).to_s][:style] = '0'
-    end
-
-    @row_styles[(row+1).to_s][:style] =
-      modify_alignment(@workbook,@row_styles[(row+1).to_s][:style],is_horizontal,alignment)
-
-    @sheet_data[row].each do |c|
-      unless c.nil?
-        if is_horizontal
-          c.change_horizontal_alignment(alignment)
-        else
-          c.change_vertical_alignment(alignment)
-        end
+    sheet_data[row].cells.each { |c|
+      next if c.nil?
+      if is_horizontal then c.change_horizontal_alignment(alignment)
+      else                  c.change_vertical_alignment(alignment)
       end
-    end
+    }
   end
 
-  def change_column_alignment(col,alignment,is_horizontal)
+  def change_column_alignment(column_index, alignment, is_horizontal)
     validate_workbook
-    validate_nonnegative(col)
+    ensure_cell_exists(0, column_index)
 
-    increase_columns(col)
+    cols.get_range(column_index).style = @workbook.modify_alignment(get_col_style(column_index), is_horizontal, alignment)
 
-    i = get_cols_index(col)
-
-    if @cols[i].nil?
-      style_index = 0
-    else
-      style_index = Integer(@cols[i][:attributes][:style])
-    end
-
-    style_index = modify_alignment(@workbook,style_index,is_horizontal,alignment)
-
-    change_cols(i,col)
-
-    @cols[i][:attributes][:style] = style_index
-
-    @sheet_data.each_with_index do |row,i|
-      c = row[Integer(col)]
-      unless c.nil?
-        if is_horizontal
-          c.change_horizontal_alignment(alignment)
-        else
-          c.change_vertical_alignment(alignment)
-        end
+    sheet_data.rows.each { |row|
+      c = row[column_index]
+      next if c.nil?
+      if is_horizontal
+        c.change_horizontal_alignment(alignment)
+      else
+        c.change_vertical_alignment(alignment)
       end
-    end
+    }
   end
 
   def change_row_border(row, direction, weight)
     validate_workbook
-    validate_nonnegative(row)
-    validate_border(weight)
-    increase_rows(row)
+    ensure_cell_exists(row)
 
-    if @row_styles[(row+1).to_s].nil?
-      @row_styles[(row+1).to_s]= {}
-      @row_styles[(row+1).to_s][:style] = '0'
-    end
-    @row_styles[(row+1).to_s][:style] = modify_border(@workbook,@row_styles[(row+1).to_s][:style])
+    sheet_data.rows[row].s = @workbook.modify_border(get_row_style(row), direction, weight)
 
-    if @workbook.borders[xf_attr_row(row)[:borderId]][:border][direction][:attributes].nil?
-      @workbook.borders[xf_attr_row(row)[:borderId]][:border][direction][:attributes] = { :style => nil }
-    end
-    @workbook.borders[xf_attr_row(row)[:borderId]][:border][direction][:attributes][:style] = weight.to_s
-
-    @sheet_data[row].each do |c|
-      unless c.nil?
-        case direction
-          when :top
-            c.change_border_top(weight)
-          when :left
-            c.change_border_left(weight)
-          when :right
-            c.change_border_right(weight)
-          when :bottom
-            c.change_border_bottom(weight)
-          when :diagonal
-            c.change_border_diagonal(weight)
-          else
-            raise 'invalid direction'
-        end
+    sheet_data[row].cells.each { |c|
+      next if c.nil?
+      case direction
+      when :top      then c.change_border_top(weight)
+      when :left     then c.change_border_left(weight)
+      when :right    then c.change_border_right(weight)
+      when :bottom   then c.change_border_bottom(weight)
+      when :diagonal then c.change_border_diagonal(weight)
+      else raise 'invalid direction'
       end
-    end
+    }
   end
 
-  def change_column_border(col,direction,weight)
+  def change_column_border(column_index, direction, weight)
     validate_workbook
-    validate_nonnegative(col)
-    validate_border(weight)
+    ensure_cell_exists(0, column_index)
 
-    increase_columns(col)
+    cols.get_range(column_index).style = @workbook.modify_border(get_col_style(column_index), direction, weight)
 
-    i = get_cols_index(col)
-    if @cols[i].nil?
-      style_index = 0
-    else
-      style_index = Integer(@cols[i][:attributes][:style])
-    end
-
-    style_index = modify_border(@workbook,style_index)
-
-    change_cols(i,col)
-
-    xf = @workbook.get_style_attributes(@workbook.get_style(style_index))
-
-    if @workbook.borders[xf[:borderId]][:border][direction][:attributes].nil?
-      @workbook.borders[xf[:borderId]][:border][direction][:attributes] = { :style => nil }
-    end
-    @workbook.borders[xf[:borderId]][:border][direction][:attributes][:style] = weight.to_s
-
-    @sheet_data.each_with_index do |row,i|
-      c = row[Integer(col)]
-      unless c.nil?
-        case direction
-          when :top
-            c.change_border_top(weight)
-          when :left
-            c.change_border_left(weight)
-          when :right
-            c.change_border_right(weight)
-          when :bottom
-            c.change_border_bottom(weight)
-          when :diagonal
-            c.change_border_diagonal(weight)
-          else
-            raise 'invalid direction'
-        end
+    sheet_data.rows.each { |row|
+      c = row.cells[column_index]
+      next if c.nil?
+      case direction
+      when :top      then c.change_border_top(weight)
+      when :left     then c.change_border_left(weight)
+      when :right    then c.change_border_right(weight)
+      when :bottom   then c.change_border_bottom(weight)
+      when :diagonal then c.change_border_diagonal(weight)
+      else raise 'invalid direction'
       end
-    end
+    }
   end
 
   def add_cell_style(row,column)
-    xf = @workbook.get_style_attributes(@workbook.get_style(@sheet_data[row][column].style_index))
-    @workbook.fonts[xf[:fontId].to_s][:count] += 1
-    @workbook.fills[xf[:fillId].to_s][:count] += 1
-    @workbook.borders[xf[:borderId].to_s][:count] += 1
+    xf = @workbook.cell_xfs[sheet_data.rows[row].cells[column].style_index]
+    @workbook.fonts[xf.font_id].count += 1
+    @workbook.fills[xf.fill_id].count += 1
+    @workbook.borders[xf.border_id].count += 1
   end
 
-  # finds first row which contains at least all strings in cells_content
-  def find_first_row_with_content(cells_content)
-    validate_workbook
-    index = nil
+  def validate_nonnegative(row_or_col)
+    raise 'Row and Column arguments must be nonnegative' if row_or_col < 0
+  end
+  private :validate_nonnegative
 
-    @sheet_data.each_with_index do |row, index|
-      cells_content = cells_content.map { |header| header.to_s.downcase.strip }
-      original_cells_content = row.map { |cell| cell.nil? ? '' : cell.value.to_s.downcase.strip }
-      if (cells_content & original_cells_content).size == cells_content.size
-        return index
-      end
-    end
-    return nil
+  def column_exists(col)
+    sheet_data.rows[0].cells.size > col
   end
 
+  def row_exists(row)
+    sheet_data.rows.size > row
+  end
+
+
 end #end class
 end