axlsx-alt 3.0.0

data/lib/axlsx/workbook/worksheet/row.rb

@@ -0,0 +1,161 @@
+# encoding: UTF-8
+module Axlsx
+  # A Row is a single row in a worksheet.
+  # @note The recommended way to manage rows and cells is to use Worksheet#add_row
+  # @see Worksheet#add_row
+  class Row < SimpleTypedList
+    include SerializedAttributes
+    include Accessors
+    
+    # No support is provided for the following attributes
+    # spans
+    # thickTop
+    # thickBottom
+
+   # Creates a new row. New Cell objects are created based on the values, types and style options.
+    # A new cell is created for each item in the values array. style and types options are applied as follows:
+    #   If the types option is defined and is a symbol it is applied to all the cells created.
+    #   If the types option is an array, cell types are applied by index for each cell
+    #   If the types option is not set, the cell will automatically determine its type.
+    #   If the style option is defined and is an Integer, it is applied to all cells created.
+    #   If the style option is an array, style is applied by index for each cell.
+    #   If the style option is not defined, the default style (0) is applied to each cell.
+    # @param [Worksheet] worksheet
+    # @option options [Array] values
+    # @option options [Array, Symbol] types
+    # @option options [Array, Integer] style
+    # @option options [Float] height the row's height (in points)
+    # @see Row#array_to_cells
+    # @see Cell
+    def initialize(worksheet, values=[], options={})
+      self.worksheet = worksheet
+      super(Cell, nil, values.size)
+      self.height = options.delete(:height)
+      worksheet.rows << self
+      array_to_cells(values, options)
+    end
+
+    # A list of serializable attributes.
+    serializable_attributes :hidden, :outline_level, :collapsed, :custom_format, :s, :ph, :custom_height, :ht
+
+    # Boolean row attribute accessors
+    boolean_attr_accessor :hidden, :collapsed, :custom_format, :ph, :custom_height
+
+    # The worksheet this row belongs to
+    # @return [Worksheet]
+    attr_reader :worksheet
+
+    # Row height measured in point size. There is no margin padding on row height.
+    # @return [Float]
+    def height
+      defined?(@ht) ? @ht : nil
+    end
+
+    # Outlining level of the row, when outlining is on
+    # @return [Integer]
+    attr_reader :outline_level
+    alias :outlineLevel :outline_level
+
+    # The style applied ot the row. This affects the entire row.
+    # @return [Integer]
+    attr_reader :s
+
+    # @see Row#s
+    def s=(v)
+      Axlsx.validate_unsigned_numeric(v)
+      @custom_format = true 
+      @s = v
+    end
+
+    # @see Row#outline
+    def outline_level=(v)
+      Axlsx.validate_unsigned_numeric(v)
+      @outline_level = v
+    end
+    
+    alias :outlineLevel= :outline_level=
+
+    # The index of this row in the worksheet
+    # @return [Integer]
+    def row_index
+      worksheet.rows.index(self)
+    end
+
+    # Serializes the row
+    # @param [Integer] r_index The row index, 0 based.
+    # @param [String] str The string this rows xml will be appended to.
+    # @return [String]
+    def to_xml_string(r_index, str = '')
+      serialized_tag('row', str, :r => r_index + 1) do
+        tmp = '' # time / memory tradeoff, lots of calls to rubyzip costs more
+                 # time..
+        each_with_index { |cell, c_index| cell.to_xml_string(r_index, c_index, tmp) }
+        str << tmp
+      end
+    end
+
+    # Adds a single cell to the row based on the data provided and updates the worksheet's autofit data.
+    # @return [Cell]
+    def add_cell(value = '', options = {})
+      c = Cell.new(self, value, options)
+      self << c
+      worksheet.send(:update_column_info, self, [])
+      c
+    end
+
+    # sets the color for every cell in this row
+    def color=(color)
+      each_with_index do | cell, index |
+        cell.color = color.is_a?(Array) ? color[index] : color
+      end
+    end
+
+    # sets the style for every cell in this row
+    def style=(style)
+      each_with_index do | cell, index |
+        cell.style = style.is_a?(Array) ? style[index] : style
+      end
+    end
+
+    # @see height
+    def height=(v)
+      unless v.nil?
+        Axlsx::validate_unsigned_numeric(v)
+        @custom_height = true
+        @ht = v
+      end
+    end
+    
+    # return cells
+    def cells
+      self
+    end
+
+    private
+
+    # assigns the owning worksheet for this row
+    def worksheet=(v) DataTypeValidator.validate :row_worksheet, Worksheet, v; @worksheet=v; end
+
+    # Converts values, types, and style options into cells and associates them with this row.
+    # A new cell is created for each item in the values array.
+    # If value option is defined and is a symbol it is applied to all the cells created.
+    # If the value option is an array, cell types are applied by index for each cell
+    # If the style option is defined and is an Integer, it is applied to all cells created.
+    # If the style option is an array, style is applied by index for each cell.
+    # @option options [Array] values
+    # @option options [Array, Symbol] types
+    # @option options [Array, Integer] style
+    def array_to_cells(values, options={})
+      DataTypeValidator.validate :array_to_cells, Array, values
+      types, style, formula_values = options.delete(:types), options.delete(:style), options.delete(:formula_values)
+      values.each_with_index do |value, index|
+        options[:style] = style.is_a?(Array) ? style[index] : style if style
+        options[:type] = types.is_a?(Array) ? types[index] : types if types
+        options[:formula_value] = formula_values[index] if formula_values.is_a?(Array)
+
+        self[index] = Cell.new(self, value, options)
+      end
+    end
+  end
+
+end

data/lib/axlsx/workbook/worksheet/row_breaks.rb

@@ -0,0 +1,33 @@
+module Axlsx
+
+  # A collection of break objects that define row breaks (page breaks) for printing and preview
+
+  class RowBreaks < SimpleTypedList
+
+    def initialize
+      super Break
+    end
+
+    # Adds a row break
+    # @param [Hash] options The options for the break to be created.
+    # max and man values are fixed.
+    # @see Break
+    def add_break(options)
+      # force feed the excel default
+      self << Break.new(options.merge(:max => 16383, :man => true))
+      last
+    end
+ 
+    # <rowBreaks count="3" manualBreakCount="3">
+    # <brk id="1" max="16383" man="1"/>
+    # <brk id="7" max="16383" man="1"/>
+    # <brk id="13" max="16383" man="1"/>
+    # </rowBreaks>
+    def to_xml_string(str='')
+      return if empty?
+      str << ('<rowBreaks count="' << self.size.to_s << '" manualBreakCount="' << self.size.to_s << '">')
+      each { |brk| brk.to_xml_string(str) }
+      str << '</rowBreaks>'
+    end
+  end
+end

data/lib/axlsx/workbook/worksheet/selection.rb

@@ -0,0 +1,101 @@
+# encoding: UTF-8
+module Axlsx
+  # Selection options for worksheet panes.
+  #
+  # @note The recommended way to manage the selection pane options is via SheetView#add_selection
+  # @see SheetView#add_selection
+  class Selection
+
+    include Axlsx::OptionsParser
+    include Axlsx::SerializedAttributes
+
+    # Creates a new {Selection} object
+    # @option options [Cell, String] active_cell Active Cell Location
+    # @option options [Integer] active_cell_id Active Cell Index
+    # @option options [Symbol] pane Pane
+    # @option options [String] sqref Sequence of References
+    def initialize(options={})
+      @active_cell = @active_cell_id = @pane = @sqref = nil
+      parse_options options
+    end
+
+    serializable_attributes :active_cell, :active_cell_id, :pane, :sqref
+    # Active Cell Location
+    # Location of the active cell.
+    # @see type
+    # @return [String]
+    # default nil
+    attr_reader :active_cell
+
+    # Active Cell Index
+    # 0-based index of the range reference (in the array of references listed in sqref)
+    # containing the active cell. Only used when the selection in sqref is not contiguous.
+    # Therefore, this value needs to be aware of the order in which the range references are
+    # written in sqref.
+    # When this value is out of range then activeCell can be used.
+    # @see type
+    # @return [Integer]
+    # default nil
+    attr_reader :active_cell_id
+
+    # Pane
+    # The pane to which this selection belongs.
+    # Options are 
+    #  * bottom_left:  Bottom left pane, when both vertical and horizontal
+    #                  splits are applied. This value is also used when only
+    #                  a horizontal split has been applied, dividing the pane 
+    #                  into upper and lower regions. In that case, this value 
+    #                  specifies the bottom pane.
+    #  * bottom_right: Bottom right pane, when both vertical and horizontal
+    #                  splits are applied.
+    #  * top_left:     Top left pane, when both vertical and horizontal splits
+    #                  are applied. This value is also used when only a horizontal 
+    #                  split has been applied, dividing the pane into upper and lower
+    #                  regions. In that case, this value specifies the top pane.
+    #                  This value is also used when only a vertical split has
+    #                  been applied, dividing the pane into right and left
+    #                  regions. In that case, this value specifies the left pane
+    #  * top_right:    Top right pane, when both vertical and horizontal
+    #                  splits are applied. This value is also used when only
+    #                  a vertical split has been applied, dividing the pane 
+    #                  into right and left regions. In that case, this value 
+    #                  specifies the right pane.
+    # @see type
+    # @return [Symbol]
+    # default nil
+    attr_reader :pane
+
+    # Sequence of References
+    # Range of the selection. Can be non-contiguous set of ranges.
+    # @see type
+    # @return [String]
+    # default nil
+    attr_reader :sqref
+
+    # @see active_cell
+    def active_cell=(v)
+      cell = (v.class == Axlsx::Cell ? v.r_abs : v)
+      Axlsx::validate_string(cell)
+      @active_cell = cell
+    end
+
+    # @see active_cell_id
+    def active_cell_id=(v); Axlsx::validate_unsigned_int(v); @active_cell_id = v end
+
+    # @see pane
+    def pane=(v)
+      Axlsx::validate_pane_type(v)
+      @pane = Axlsx::camel(v, false)
+    end
+
+    # @see sqref
+    def sqref=(v); Axlsx::validate_string(v); @sqref = v end
+
+    # Serializes the data validation
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      serialized_tag 'selection', str
+    end
+  end
+end

data/lib/axlsx/workbook/worksheet/sheet_calc_pr.rb

@@ -0,0 +1,29 @@
+module Axlsx
+
+  # the SheetCalcPr object for the worksheet
+  # This object contains calculation properties for the worksheet.
+  class SheetCalcPr
+   include Axlsx::OptionsParser
+   include Axlsx::SerializedAttributes
+   include Axlsx::Accessors
+    # creates a new SheetCalcPr
+    # @param [Hash] options Options for this object
+    # @option [Boolean] full_calc_on_load @see full_calc_on_load
+    def initialize(options={})
+      @full_calc_on_load = true
+      parse_options options
+    end
+
+    boolean_attr_accessor :full_calc_on_load
+
+    serializable_attributes :full_calc_on_load
+
+    # Serialize the object
+    # @param [String] str the string to append this objects serialized
+    # content to.
+    # @return [String]
+    def to_xml_string(str='')
+      str << "<sheetCalcPr #{serialized_attributes}/>"
+    end
+  end
+end

data/lib/axlsx/workbook/worksheet/sheet_data.rb

@@ -0,0 +1,27 @@
+module Axlsx
+
+  # This class manages the serialization of rows for worksheets
+  class SheetData
+
+    # Creates a new SheetData object
+    # @param [Worksheet] worksheet The worksheet that owns this sheet data.
+    def initialize(worksheet)
+      raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
+      @worksheet = worksheet
+    end
+    
+    attr_reader :worksheet
+
+    # Serialize the sheet data
+    # @param [String] str the string this objects serializaton will be concacted to.
+    # @return [String]
+    def to_xml_string(str = '')
+      str << '<sheetData>'
+      worksheet.rows.each_with_index do |row, index| 
+        row.to_xml_string(index, str) 
+      end
+      str << '</sheetData>'
+    end
+    
+  end
+end

data/lib/axlsx/workbook/worksheet/sheet_format_pr.rb

@@ -0,0 +1,60 @@
+module Axlsx
+
+  #Sheet formatting properties
+  # <xsd:complexType name="CT_SheetFormatPr">
+  #   <xsd:attribute name="baseColWidth" type="xsd:unsignedInt" use="optional" default="8"/>
+  #   <xsd:attribute name="defaultColWidth" type="xsd:double" use="optional"/>
+  #   <xsd:attribute name="defaultRowHeight" type="xsd:double" use="required"/>
+  #   <xsd:attribute name="customHeight" type="xsd:boolean" use="optional" default="false"/>
+  #   <xsd:attribute name="zeroHeight" type="xsd:boolean" use="optional" default="false"/>
+  #   <xsd:attribute name="thickTop" type="xsd:boolean" use="optional" default="false"/>
+  #   <xsd:attribute name="thickBottom" type="xsd:boolean" use="optional" default="false"/>
+  #   <xsd:attribute name="outlineLevelRow" type="xsd:unsignedByte" use="optional" default="0"/>
+  #   <xsd:attribute name="outlineLevelCol" type="xsd:unsignedByte" use="optional" default="0"/>
+  #</xsd:complexType>
+
+  class SheetFormatPr
+    include Axlsx::SerializedAttributes
+    include Axlsx::OptionsParser
+    include Axlsx::Accessors
+
+    # creates a new sheet_format_pr object
+    # @param [Hash] options initialization options
+    # @option [Integer] base_col_width Specifies the number of characters of the maximum digit width of the normal style's font. This value does not include margin padding or extra padding for gridlines. It is only the number of characters.
+    # @option [Float] default_col_width Default column width measured as the number of characters of the maximum digit width of the normal style's font.
+    # @option [Float] default_row_height Default row height measured in point size. Optimization so we don't have to write the height on all rows. This can be written out if most rows have custom height, to achieve the optimization.
+    # @option [Boolean] custom_height 'True' if defaultRowHeight value has been manually set, or is different from the default value.
+    # @option [Boolean] zero_height 'True' if rows are hidden by default. This setting is an optimization used when most rows of the sheet are hidden.
+    # @option [Boolean] think_top 'True' if rows have a thick top border by default.
+    # @option [Boolean] thick_bottom 'True' if rows have a thick bottom border by default.
+    # @option [Integer] outline_level_row Highest number of outline level for rows in this sheet. These values shall be in synch with the actual sheet outline levels.
+    # @option [Integer] outline_level_col Highest number of outline levels for columns in this sheet. These values shall be in synch with the actual sheet outline levels.
+    def initialize(options={})
+      set_defaults
+      parse_options options
+    end
+
+    serializable_attributes :base_col_width, :default_col_width, :default_row_height,
+      :custom_height, :zero_height, :thick_top, :thick_bottom,
+      :outline_level_row, :outline_level_col
+
+    float_attr_accessor :default_col_width, :default_row_height
+
+    boolean_attr_accessor :custom_height, :zero_height, :thick_top, :thick_bottom
+
+    unsigned_int_attr_accessor :base_col_width, :outline_level_row, :outline_level_col 
+
+    # serializes this object to an xml string
+    # @param [String] str The string this objects serialization will be appended to
+    # @return [String]
+    def to_xml_string(str='')
+      str << "<sheetFormatPr #{serialized_attributes}/>"
+    end
+
+    private
+    def set_defaults
+      @base_col_width = 8
+      @default_row_height = 18
+    end
+  end
+end

data/lib/axlsx/workbook/worksheet/sheet_pr.rb

@@ -0,0 +1,87 @@
+module Axlsx
+
+  # The SheetPr class manages serialization of a worksheet's sheetPr element.
+  class SheetPr
+    include Axlsx::OptionsParser
+    include Axlsx::Accessors
+    include Axlsx::SerializedAttributes
+
+    serializable_attributes :sync_horizontal,
+                            :sync_vertical,
+                            :transition_evaluation,
+                            :transition_entry,
+                            :published,
+                            :filter_mode,
+                            :enable_format_conditions_calculation,
+                            :code_name,
+                            :sync_ref
+
+    # These attributes are all boolean so I'm doing a bit of a hand
+    # waving magic show to set up the attriubte accessors
+    boolean_attr_accessor :sync_horizontal,
+                          :sync_vertical,
+                          :transition_evaluation,
+                          :transition_entry,
+                          :published,
+                          :filter_mode,
+                          :enable_format_conditions_calculation
+
+    string_attr_accessor :code_name, :sync_ref
+
+    # Creates a new SheetPr object
+    # @param [Worksheet] worksheet The worksheet that owns this SheetPr object
+    def initialize(worksheet, options={})
+      raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
+      @worksheet = worksheet
+      @outline_pr = nil
+      parse_options options
+    end
+
+    # The worksheet these properties apply to!
+    # @return [Worksheet]
+    attr_reader :worksheet
+
+    # The tab color of the sheet.
+    # @return [Color]
+    attr_reader :tab_color
+
+    # Serialize the object
+    # @param [String] str serialized output will be appended to this object if provided.
+    # @return [String]
+    def to_xml_string(str = '')
+      update_properties
+      str << "<sheetPr #{serialized_attributes}>"
+      tab_color.to_xml_string(str, 'tabColor') if tab_color
+      outline_pr.to_xml_string(str) if @outline_pr
+      page_setup_pr.to_xml_string(str)
+      str << "</sheetPr>"
+    end
+
+    # The PageSetUpPr for this sheet pr object
+    # @return [PageSetUpPr]
+    def page_setup_pr
+      @page_setup_pr ||= PageSetUpPr.new
+    end
+    
+    # The OutlinePr for this sheet pr object
+    # @return [OutlinePr]
+    def outline_pr
+      @outline_pr ||= OutlinePr.new
+    end
+
+    # @see tab_color
+    def tab_color=(v)
+      @tab_color ||= Color.new(:rgb => v)
+    end
+
+    private
+
+    def update_properties
+      page_setup_pr.fit_to_page = worksheet.fit_to_page?
+      if worksheet.auto_filter.columns.size > 0
+        self.filter_mode = 1
+        self.enable_format_conditions_calculation = 1
+      end
+    end
+  end
+end