dg-axlsx 2.1.0

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,79 @@
+module Axlsx
+
+  # The SheetPr class manages serialization fo 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
+      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
+      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
+
+    # @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

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

@@ -0,0 +1,118 @@
+# encoding: UTF-8
+module Axlsx
+
+  # The SheetProtection object manages worksheet protection options per sheet.
+  class SheetProtection
+
+    include Axlsx::OptionsParser
+    include Axlsx::SerializedAttributes
+    include Axlsx::Accessors
+
+    # Creates a new SheetProtection instance
+    # @option options [Boolean] sheet @see SheetProtection#sheet
+    # @option options [Boolean] objects @see SheetProtection#objects
+    # @option options [Boolean] scenarios @see SheetProtection#scenarios
+    # @option options [Boolean] format_cells @see SheetProtection#objects
+    # @option options [Boolean] format_columns @see SheetProtection#format_columns
+    # @option options [Boolean] format_rows @see SheetProtection#format_rows
+    # @option options [Boolean] insert_columns @see SheetProtection#insert_columns
+    # @option options [Boolean] insert_rows @see SheetProtection#insert_rows
+    # @option options [Boolean] insert_hyperlinks @see SheetProtection#insert_hyperlinks
+    # @option options [Boolean] delete_columns @see SheetProtection#delete_columns
+    # @option options [Boolean] delete_rows @see SheetProtection#delete_rows
+    # @option options [Boolean] select_locked_cells @see SheetProtection#select_locked_cells
+    # @option options [Boolean] sort @see SheetProtection#sort
+    # @option options [Boolean] auto_filter @see SheetProtection#auto_filter
+    # @option options [Boolean] pivot_tables @see SheetProtection#pivot_tables
+    # @option options [Boolean] select_unlocked_cells @see SheetProtection#select_unlocked_cells
+    # @option options [String] password. The password required for unlocking. @see SheetProtection#password=
+    def initialize(options={})
+      @objects = @scenarios = @select_locked_cells = @select_unlocked_cells = false
+      @sheet = @format_cells = @format_rows = @format_columns = @insert_columns = @insert_rows = @insert_hyperlinks = @delete_columns = @delete_rows = @sort = @auto_filter = @pivot_tables = true
+      @password = nil
+      parse_options options
+    end
+
+    boolean_attr_accessor :sheet, :objects, :scenarios, :format_cells, :format_columns, :format_rows,
+      :insert_columns, :insert_rows, :insert_hyperlinks, :delete_columns, :delete_rows,
+      :select_locked_cells, :sort, :auto_filter, :pivot_tables, :select_unlocked_cells
+
+    serializable_attributes :sheet, :objects, :scenarios, :format_cells, :format_columns, :format_rows,
+      :insert_columns, :insert_rows, :insert_hyperlinks, :delete_columns, :delete_rows,
+      :select_locked_cells, :sort, :auto_filter, :pivot_tables, :select_unlocked_cells, :salt, :password
+
+    # Specifies the salt which was prepended to the user-supplied password before it was hashed using the hashing algorithm
+    # @return [String]
+    attr_reader :salt_value
+
+    # Password hash
+    # @return [String]
+    # default nil
+    attr_reader :password
+
+    # This block is intended to implement the salt_value, hash_value and spin count as per the ECMA-376 standard. 
+    # However, it does not seem to actually work in EXCEL - instead they are using their old retro algorithm shown below 
+    # defined in the transitional portion of the speck. I am leaving this code in in the hope that someday Ill be able to 
+    # figure out why it does not work, and if Excel even supports it.
+    #     def propper_password=(v)
+    #       @algorithm_name = v == nil ? nil : 'SHA-1'
+    #       @salt_value = @spin_count = @hash_value = v if v == nil
+    #       return if v == nil
+    #       require 'digest/sha1'
+    #       @spin_count = 10000
+    #       @salt_value = Digest::SHA1.hexdigest(rand(36**8).to_s(36))
+    #       @spin_count.times do |count|
+    #         @hash_value = Digest::SHA1.hexdigest((@hash_value ||= (@salt_value + v.to_s)) + Array(count).pack('V'))
+    #       end
+    #     end
+
+    # encodes password for protection locking
+    def password=(v)
+      return if v == nil
+      @password = create_password_hash(v)
+    end
+
+    # Serialize the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str = '')
+      serialized_tag('sheetProtection', str)
+    end
+
+    private
+    # Creates a password hash for a given password
+    # @return [String]
+    def create_password_hash(password)
+      encoded_password = encode_password(password)
+
+      password_as_hex = [encoded_password].pack("v")
+      password_as_string = password_as_hex.unpack("H*").first.upcase
+
+      password_as_string[2..3] + password_as_string[0..1]
+    end
+
+    # Encodes a given password
+    # Based on the algorithm provided by Daniel Rentz of OpenOffice.
+    # http://www.openoffice.org/sc/excelfileformat.pdf, Revision 1.42, page 115 (21.05.2012)
+    # @return [String]
+    def encode_password(password)
+      i = 0
+      chars = password.split(//)
+      count = chars.size
+
+      chars.collect! do |char|
+        i += 1
+        char     = char.unpack('c')[0] << i #ord << i
+        low_15   = char & 0x7fff
+        high_15  = char & 0x7fff << 15
+        high_15  = high_15 >> 15
+        char     = low_15 | high_15
+      end
+
+      encoded_password  = 0x0000
+      chars.each { |c| encoded_password ^= c }
+      encoded_password ^= count
+      encoded_password ^= 0xCE4B
+    end
+  end
+end