axlsx 1.2.1 → 1.3.1

data/lib/axlsx/workbook/worksheet/auto_filter/filters.rb

@@ -0,0 +1,253 @@
+module Axlsx
+
+  # When multiple values are chosen to filter by, or when a group of date values are chosen to filter by, 
+  # this object groups those criteria together.
+  class Filters
+
+    # Allowed calendar types
+    CALENDAR_TYPES = %w(gregorian gregorianUs gregorianMeFrench gregorianArabic hijri hebrew taiwan japan thai korea saka gregorianXlitEnglish gregorianXlitFrench none)
+
+    # Creates a new Filters object
+    # @param [Hash] options Options used to set this objects attributes and
+    #                       create filter and/or date group items
+    # @option [Boolean] blank @see blank
+    # @option [String] calendar_type @see calendar_type
+    # @option [Array] filter_items An array of values that will be used to create filter objects.
+    # @option [Array] date_group_items An array of hases defining date group item filters to apply.
+    # @note The recommended way to interact with filter objects is via AutoFilter#add_column
+    # @example
+    #   ws.auto_filter.add_column(0, :filters, :blank => true, :calendar_type => 'japan', :filter_items => [100, 'a'])
+    def initialize(options={})
+      options.each do |key, value|
+        self.send("#{key}=", value) if self.respond_to? "#{key}="
+      end
+    end
+
+    # Flag indicating whether to filter by blank.
+    # @return [Boolean]
+    attr_reader :blank
+
+    # Calendar type for date grouped items. 
+    # Used to interpret the values in dateGroupItem.
+    # This is the calendar type used to evaluate all dates in the filter column,
+    # even when those dates are not using the same calendar system / date formatting.
+    attr_reader :calendar_type
+
+    # Tells us if the row of the cell provided should be filterd as it
+    # does not meet any of the specified filter_items or
+    # date_group_items restrictions.
+    # @param [Cell] cell The cell to test against items
+    # TODO implement this for date filters as well!
+    def apply(cell)
+      return false unless cell
+      filter_items.each do |filter|
+        return false if cell.value == filter.val
+      end
+      true
+    end
+      
+    # The filter values in this filters object
+    def filter_items
+      @filter_items ||= []
+    end
+
+    # the date group values in this filters object
+    def date_group_items
+      @date_group_items ||= []
+    end
+
+    # @see calendar_type
+    # @param [String] calendar The calendar type to use. This must be one of the types defined in CALENDAR_TYPES
+    # @return [String]
+    def calendar_type=(calendar)
+      RestrictionValidator.validate 'Filters.calendar_type', CALENDAR_TYPES, calendar
+      @calendar_type = calendar
+    end
+
+    # Set the value for blank
+    # @see blank
+    def blank=(use_blank)
+      Axlsx.validate_boolean use_blank
+      @blank = use_blank
+    end
+
+    # Serialize the object to xml
+    def to_xml_string(str = '')
+      str << "<filters #{serialized_attributes}>"
+      filter_items.each {  |filter| filter.to_xml_string(str) }
+      date_group_items.each { |date_group_item| date_group_item.to_xml_string(str) }
+      str << '</filters>'
+    end
+
+    # not entirely happy with this. 
+    # filter_items should be a simple typed list that overrides << etc
+    # to create Filter objects from the inserted values. However this
+    # is most likely so rarely used...(really? do you know that?)
+    def filter_items=(values)
+      values.each do |value|
+        filter_items << Filter.new(value)
+      end
+    end
+
+    # Date group items are date group filter items where you specify the
+    # date_group and a value for that option as part of the auto_filter
+    # @note This can be specified, but will not be applied to the date
+    # values in your workbook at this time.
+    def date_group_items=(options)
+      options.each do |date_group|
+        raise ArgumentError, "date_group_items should be an array of hashes specifying the options for each date_group_item" unless date_group.is_a?(Hash)
+        date_group_items << DateGroupItem.new(date_group)
+      end
+    end
+
+    private
+
+    def serialized_attributes(str='')
+      instance_values.each do |key, value|
+        if %(blank claendar_type).include? key.to_s
+        str << "#{Axlsx.camel(key, false)}='#{value}' "
+        end
+      end
+      str
+    end
+
+    # This class expresses a filter criteria value.
+    class Filter
+
+      # Creates a new filter value object
+      # @param [Any] value   The value of the filter. This is not restricted, but
+      #                       will be serialized via to_s so if you are passing an object
+      #                       be careful.
+      def initialize(value)
+        @val = value
+      end
+
+
+      #Filter value used in the criteria.
+      attr_accessor :val
+
+      # Serializes the filter value object
+      # @param [String] str The string to concact the serialization information to.
+      def to_xml_string(str = '')
+        str << "<filter val='#{@val.to_s}' />"
+      end
+    end
+
+
+    # This collection is used to express a group of dates or times which are
+    # used in an AutoFilter criteria. Values are always written in the calendar
+    # type of the first date encountered in the filter range, so that all
+    # subsequent dates, even when formatted or represented by other calendar
+    # types, can be correctly compared for the purposes of filtering.
+    class DateGroupItem
+
+      # Allowed date time groupings
+      DATE_TIME_GROUPING = %w(year month day hour minute second)
+
+      # Creates a new DateGroupItem
+      # @param [Hash] options A hash of options to use when
+      # instanciating the object
+      # @option [String] date_time_grouping the part of the date this
+      # filter should apply for grouping
+      # @option [Integer|String] year @see year
+      # @option [Integer] month @see month
+      # @option [Integer] day @see day
+      # @option [Integer] hour @see hour
+      # @option [Integer] minute @see minute
+      # @option [Integer] second @see second
+      def initialize(options={})
+        raise ArgumentError,  "You must specify a year for date time grouping" unless options[:year]
+        raise ArgumentError, "You must specify a date_time_grouping when creating a DateGroupItem for auto filter" unless options[:date_time_grouping]
+        options.each do |key, value|
+          self.send("#{key}=", value) if self.respond_to?("#{key}=")
+        end
+      end
+
+      # Grouping level
+      # This must be one of year, month, day, hour, minute or second.
+      # @return [String]
+      attr_reader :date_time_grouping
+
+      # Year (4 digits)
+      # @return [Integer|String]
+      attr_reader :year
+
+      # Month (1..12)
+      # @return [Integer]
+      attr_reader :month
+
+      # Day (1-31)
+      # @return [Integer]
+      attr_reader :day
+
+      # Hour (0..23)
+      # @return [Integer]
+      attr_reader :hour
+
+      # Minute (0..59(
+      # @return [Integer]
+      attr_reader :minute
+
+      # Second (0..59)
+      # @return [Integer]
+      attr_reader :second
+
+      # The year value for the date group item
+      # This must be a four digit value
+      def year=(value)
+        RegexValidator.validate "DateGroupItem.year", /\d{4}/, value
+        @year = value
+      end
+
+      # The month value for the date group item
+      # This must be between 1 and 12
+      def month=(value)
+        RangeValidator.validate "DateGroupItem.month", 0, 12, value
+        @month = value
+      end
+
+      # The day value for the date group item
+      # This must be between 1 and 31 
+      # @note no attempt is made to ensure the date value is valid for any given month
+      def day=(value)
+        RangeValidator.validate "DateGroupItem.day", 0, 31, value
+        @day = value
+      end
+
+      # The hour value for the date group item
+      # # this must be between 0 and 23
+      def hour=(value)
+        RangeValidator.validate "DateGroupItem.hour", 0, 23, value
+        @hour = value
+      end
+
+      # The minute value for the date group item
+      # This must be between 0 and 59
+      def minute=(value)
+         RangeValidator.validate "DateGroupItem.minute", 0, 59, value
+         @minute = value
+      end
+
+      # The second value for the date group item
+      # This must be between 0 and 59
+      def second=(value)
+        RangeValidator.validate "DateGroupItem.second", 0, 59, value
+        @second = value
+      end
+
+      # The date time grouping for this filter.
+      def date_time_grouping=(grouping)
+        RestrictionValidator.validate 'DateGroupItem.date_time_grouping', DATE_TIME_GROUPING, grouping.to_s
+        @date_time_grouping = grouping.to_s
+      end
+
+      # Serialize the object to xml
+      # @param [String] str The string object this serialization will be concatenated to.
+      def to_xml_string(str = '')
+        str << '<dateGroupItem '
+        instance_values.each { |key, value| str << "#{key}='#{value.to_s}' " }
+        str << '/>'
+      end
+    end
+  end
+end

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

@@ -330,7 +330,7 @@ module Axlsx
       font_scale = (font_size/10.0).to_f
       ((value.to_s.count(Worksheet.thin_chars) * mdw + 5) / mdw * 256) / 256.0 * font_scale
     end
-   
+
     # returns the absolute or relative string style reference for
     # this cell. 
     # @param [Boolean] absolute -when false a relative reference will be
@@ -338,12 +338,17 @@ module Axlsx
     # @return [String]
     def reference(absolute=true)
       absolute ? r_abs : r
-    end 
-    
+    end
+
     private
 
+    # we scale the font size if bold style is applied to either the style font or
+    # the cell itself. Yes, it is a bit of a hack, but it is much better than using
+    # imagemagick and loading metrics for every character.
     def font_size
-        sz || @styles.fonts[@styles.cellXfs[style].fontId].sz || @styles.fonts[0].sz
+        font = @styles.fonts[@styles.cellXfs[style].fontId] || @styles.fonts[0]
+        size_from_styles = (font.b || b) ? font.sz * 1.5 : font.sz
+        sz || size_from_styles
     end
 
     # Utility method for setting inline style attributes
@@ -380,7 +385,7 @@ module Axlsx
         :boolean
       elsif v.to_s.match(/\A[+-]?\d+?\Z/) #numeric
         :integer
-      elsif v.to_s.match(/\A[+-]?\d+\.\d+?\Z/) #float
+      elsif v.to_s.match(/\A[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?\Z/) #float
         :float
       else
         :string

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

@@ -10,7 +10,7 @@ module Axlsx
     # @return [Numeric]
     def self.date_to_serial(date)
       epoch = Axlsx::Workbook::date1904 ? Date.new(1904) : Date.new(1899, 12, 30)
-      (date-epoch).to_f
+      (date - epoch).to_f
     end
 
     # The time_to_serial methond converts a Time object its excel serialized form.

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

@@ -0,0 +1,47 @@
+module Axlsx
+
+  # Page setup properties of the worksheet
+  # This class name is not a typo, its spec.
+  class PageSetUpPr
+
+    # creates a new page setup properties object
+    # @param [Hash] options
+    # @option [Boolean] auto_page_breaks Flag indicating whether the sheet displays Automatic Page Breaks.
+    # @option [Boolean] fit_to_page Flag indicating whether the Fit to Page print option is enabled.
+    def initialize(options = {})
+      options.each do |key, value|
+        self.send("#{key}=",value) if self.respond_to?("#{key}=")
+      end
+    end
+
+    attr_reader :auto_page_breaks
+    attr_reader :fit_to_page
+
+    # Flag indicating whether the Fit to Page print option is enabled.
+    # @param [Boolean] value
+    # @return [Boolean]
+    def fit_to_page=(value)
+      Axlsx.validate_boolean value
+      @fit_to_page = value
+    end
+
+    # Flag indicating whether the sheet displays Automatic Page Breaks.
+    # @param [Boolean] value
+    # @return [Boolean]
+    def auto_page_breaks=(value)
+      Axlsx.validate_boolean value
+      @auto_page_breaks = value
+    end
+
+    # serialize to xml
+    def to_xml_string(str='')
+      str << '<pageSetUpPr ' << serialized_attributes << '/>'
+    end
+
+    private
+
+    def serialized_attributes
+      instance_values.map { |key, value| "#{Axlsx.camel(key, false)}='#{value}'" }.join(' ')
+    end
+  end
+end

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

@@ -20,11 +20,11 @@ module Axlsx
     # * useFirstPageNumber
     # * usePrinterDefaults
     # * verticalDpi
-    
+
     # Number of vertical pages to fit on.
     # @note PageSetup#fit_to is the recomended way to manage page fitting as only specifying one of fit_to_width/fit_to_height will result in the counterpart
     # being set to 1.
-     # @return [Integer]
+    # @return [Integer]
     attr_reader :fit_to_height
 
     # Number of horizontal pages to fit on.
@@ -36,7 +36,7 @@ module Axlsx
     # Orientation of the page (:default, :landscape, :portrait)
     # @return [Symbol]
     attr_reader :orientation 
-    
+
     # Height of paper (string containing a number followed by a unit identifier: "297mm", "11in")
     # @return [String]
     attr_reader :paper_height
@@ -44,11 +44,138 @@ module Axlsx
     # Width of paper (string containing a number followed by a unit identifier: "210mm", "8.5in")
     # @return [String]
     attr_reader :paper_width
-    
+
     # Print scaling (percent value, given as integer ranging from 10 to 400)
     # @return [Integer]
     attr_reader :scale
 
+    # The paper size to use in printing
+    #1 = Letter paper (8.5 in. by 11 in.)
+    #2 = Letter small paper (8.5 in. by 11 in.)
+    #3 = Tabloid paper (11 in. by 17 in.)
+    #4 = Ledger paper (17 in. by 11 in.)
+    #5 = Legal paper (8.5 in. by 14 in.)
+    #6 = Statement paper (5.5 in. by 8.5 in.)
+    #7 = Executive paper (7.25 in. by 10.5 in.)
+    #8 = A3 paper (297 mm by 420 mm)
+    #9 = A4 paper (210 mm by 297 mm)
+    #10 = A4 small paper (210 mm by 297 mm) 
+    #11 = A5 paper (148 mm by 210 mm)
+    #12 = B4 paper (250 mm by 353 mm)
+    #13 = B5 paper (176 mm by 250 mm)
+    #14 = Folio paper (8.5 in. by 13 in.)
+    #15 = Quarto paper (215 mm by 275 mm) 
+    #16 = Standard paper (10 in. by 14 in.)
+    #17 = Standard paper (11 in. by 17 in.)
+    #18 = Note paper (8.5 in. by 11 in.)
+    #19 = #9 envelope (3.875 in. by 8.875 in.) 
+    #20 = #10 envelope (4.125 in. by 9.5 in.) 
+    #21 = #11 envelope (4.5 in. by 10.375 in.) 
+    #22 = #12 envelope (4.75 in. by 11 in.)
+    #23 = #14 envelope (5 in. by 11.5 in.) 24 = C paper (17 in. by 22 in.)
+    #25 = D paper (22 in. by 34 in.)
+    #26 = E paper (34 in. by 44 in.)
+    #27 = DL envelope (110 mm by 220 mm)
+    #28 = C5 envelope (162 mm by 229 mm)
+    #29 = C3 envelope (324 mm by 458 mm)
+    #30 = C4 envelope (229 mm by 324 mm)
+    #31 = C6 envelope (114 mm by 162 mm)
+    #32 = C65 envelope (114 mm by 229 mm)
+    #33 = B4 envelope (250 mm by 353 mm)
+    #34 = B5 envelope (176 mm by 250 mm)
+    #35 = B6 envelope (176 mm by 125 mm)
+    #36 = Italy envelope (110 mm by 230 mm)
+    #37 = Monarch envelope (3.875 in. by 7.5 in.). 38 = 6 3/4 envelope (3.625 in. by 6.5 in.)
+    #39 = US standard fanfold (14.875 in. by 11 in.)
+    #40 = German standard fanfold (8.5 in. by 12 in.)
+    #41 = German legal fanfold (8.5 in. by 13 in.)
+    #42 = ISO B4 (250 mm by 353 mm)
+    #43 = Japanese double postcard (200 mm by 148 mm) 
+    #44 = Standard paper (9 in. by 11 in.)
+    #45 = Standard paper (10 in. by 11 in.)
+    #46 = Standard paper (15 in. by 11 in.)
+    #47 = Invite envelope (220 mm by 220 mm)
+    #50 = Letter extra paper (9.275 in. by 12 in.)
+    #51 = Legal extra paper (9.275 in. by 15 in.)
+    #52 = Tabloid extra paper (11.69 in. by 18 in.)
+    #53 = A4 extra paper (236 mm by 322 mm)
+    #54 = Letter transverse paper (8.275 in. by 11 in.)
+    #55 = A4 transverse paper (210 mm by 297 mm)
+    #56 = Letter extra transverse paper (9.275 in. by 12 in.) 
+    #57 = SuperA/SuperA/A4 paper (227 mm by 356 mm) 
+    #58 = SuperB/SuperB/A3 paper (305 mm by 487 mm) 
+    #59 = Letter plus paper (8.5 in. by 12.69 in.)
+    #60 = A4 plus paper (210 mm by 330 mm)
+    #61 = A5 transverse paper (148 mm by 210 mm)
+    #62 = JIS B5 transverse paper (182 mm by 257 mm)
+    #63 = A3 extra paper (322 mm by 445 mm)
+    #64 = A5 extra paper (174 mm by 235 mm)
+    #65 = ISO B5 extra paper (201 mm by 276 mm)
+    #66 = A2 paper (420 mm by 594 mm)
+    #67 = A3 transverse paper (297 mm by 420 mm)
+    #68 = A3 extra transverse paper (322 mm by 445 mm) 
+    #69 = Japanese Double Postcard (200 mm x 148 mm) 
+    #70 = A6 (105 mm x 148 mm
+    #71 = Japanese Envelope Kaku #2
+    #72 = Japanese Envelope Kaku #3
+    #73 = Japanese Envelope Chou #3
+    #74 = Japanese Envelope Chou #4
+    #75 = Letter Rotated (11in x 8 1/2 11 in)
+    #76 = A3 Rotated (420 mm x 297 mm)
+    #77 = A4 Rotated (297 mm x 210 mm)
+    #78 = A5 Rotated (210 mm x 148 mm)
+    #79 = B4 (JIS) Rotated (364 mm x 257 mm)
+    #80 = B5 (JIS) Rotated (257 mm x 182 mm)
+    #81 = Japanese Postcard Rotated (148 mm x 100 mm)
+    #82 = Double Japanese Postcard Rotated (148 mm x 200 mm) 
+    #83 = A6 Rotated (148 mm x 105 mm)
+    #84 = Japanese Envelope Kaku #2 Rotated
+    #85 = Japanese Envelope Kaku #3 Rotated
+    #86 = Japanese Envelope Chou #3 Rotated
+    #87 = Japanese Envelope Chou #4 Rotated
+    #88 = B6 (JIS) (128 mm x 182 mm)
+    #89 = B6 (JIS) Rotated (182 mm x 128 mm)
+    #90 = (12 in x 11 in)
+    #91 = Japanese Envelope You #4
+    #92 = Japanese Envelope You #4 Rotated
+    #93 = PRC 16K (146 mm x 215 mm)
+    #94 = PRC 32K (97 mm x 151 mm)
+    #95 = PRC 32K(Big) (97 mm x 151 mm)
+    #96 = PRC Envelope #1 (102 mm x 165 mm)
+    #97 = PRC Envelope #2 (102 mm x 176 mm)
+    #98 = PRC Envelope #3 (125 mm x 176 mm)
+    #99 = PRC Envelope #4 (110 mm x 208 mm)
+    #100 = PRC Envelope #5 (110 mm x 220 mm)
+    #101 = PRC Envelope #6 (120 mm x 230 mm)
+    #102 = PRC Envelope #7 (160 mm x 230 mm)
+    #103 = PRC Envelope #8 (120 mm x 309 mm)
+    #104 = PRC Envelope #9 (229 mm x 324 mm)
+    #105 = PRC Envelope #10 (324 mm x 458 mm)
+    #106 = PRC 16K Rotated
+    #107 = PRC 32K Rotated
+    #108 = PRC 32K(Big) Rotated
+    #109 = PRC Envelope #1 Rotated (165 mm x 102 mm)
+    #110 = PRC Envelope #2 Rotated (176 mm x 102 mm)
+    #111 = PRC Envelope #3 Rotated (176 mm x 125 mm)
+    #112 = PRC Envelope #4 Rotated (208 mm x 110 mm)
+    #113 = PRC Envelope #5 Rotated (220 mm x 110 mm)
+    #114 = PRC Envelope #6 Rotated (230 mm x 120 mm)
+    #115 = PRC Envelope #7 Rotated (230 mm x 160 mm)
+    #116 = PRC Envelope #8 Rotated (309 mm x 120 mm)
+    #117 = PRC Envelope #9 Rotated (324 mm x 229 mm)
+    #118 = PRC Envelope #10 Rotated (458 mm x 324 mm)
+    # @return [Integer]
+    attr_reader :paper_size
+
+
+    # Sets the paper size for printing.
+    # @see PageSetup#paper_size
+    # @return integer
+    def paper_size=(size)
+      RestrictionValidator.validate 'paper_size', (1..118), size
+      @paper_size = size
+    end
+
     # Creates a new PageSetup object
     # @option options [Integer] fit_to_height Number of vertical pages to fit on
     # @option options [Integer] fit_to_width Number of horizontal pages to fit on
@@ -56,6 +183,7 @@ module Axlsx
     # @option options [String] paper_height Height of paper (number followed by unit identifier: "297mm", "11in")
     # @option options [String] paper_width Width of paper (number followed by unit identifier: "210mm", "8.5in")
     # @option options [Integer] scale Print scaling (percent value, integer ranging from 10 to 400)
+    # @option options [Integer] paper_size - the size of paper to use
     def initialize(options = {})
       set(options)
     end
@@ -80,7 +208,7 @@ module Axlsx
     def paper_width=(v); Axlsx::validate_number_with_unit(v); @paper_width = v; end
     # @see scale
     def scale=(v); Axlsx::validate_scale_10_400(v); @scale = v; end
-    
+
     # convenience method to achieve sanity when setting fit_to_width and fit_to_height 
     # as they both default to 1 if only their counterpart is specified.
     # @note This method will overwrite any value you explicitly set via the fit_to_height or fit_to_width methods.
@@ -97,8 +225,8 @@ module Axlsx
     # We treat any page set up that has a value set for fit_to_width or fit_to_height value as fit_to_page. 
     # @return [Boolean]
     def fit_to_page?
-       # is there some better what to express this?
-       (fit_to_width != nil || fit_to_height != nil)
+      # is there some better what to express this?
+      (fit_to_width != nil || fit_to_height != nil)
     end
 
     # Serializes the page settings element.

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

@@ -0,0 +1,49 @@
+module Axlsx
+
+  # the SheetCalcPr object for the worksheet
+  # This object contains calculation properties for the worksheet.
+  class SheetCalcPr
+
+    # 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
+      options.each do |key, value|
+        self.send("#{key}=", value) if self.respond_to?("#{key}=")
+      end
+    end
+
+    # Indicates whether the application should do a full calculate on
+    # load due to contents on this sheet. After load and successful cal,c
+    # the application shall set this value to false. Set this to true
+    # when the application should calculate the workbook on load.
+    # @return [Boolean]
+    def full_calc_on_load
+      @full_calc_on_load
+    end
+
+    # specify the full_calc_on_load value
+    # @param [Boolean] value
+    # @see full_calc_on_load
+    def full_calc_on_load=(value)
+      Axlsx.validate_boolean(value)
+      @full_calc_on_load = value
+    end
+
+    # 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
+
+    private
+
+    def serialized_attributes
+      instance_values.map { |key, value| "#{Axlsx.camel(key, false)}='#{value}'" }.join(' ')
+    end
+
+  end
+end

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

@@ -1,24 +1,107 @@
 module Axlsx
 
   # The SheetPr class manages serialization fo a worksheet's sheetPr element.
-  # Only fit_to_page is implemented
   class SheetPr
 
+
+    # These attributes are all boolean so I'm doing a bit of a hand
+    # waving magic show to set up the attriubte accessors
+    BOOLEAN_ATTRIBUTES = [:sync_horizontal, 
+                          :sync_vertical, 
+                          :transtion_evaluation, 
+                          :transition_entry,
+                          :published,
+                          :filter_mode,
+                          :enable_format_conditions_calculation]
+
+
     # Creates a new SheetPr object
     # @param [Worksheet] worksheet The worksheet that owns this SheetPr object
-    def initialize(worksheet)
+    def initialize(worksheet, options={})
       raise ArgumentError, "you must provide a worksheet" unless worksheet.is_a?(Worksheet)
       @worksheet = worksheet
+      options.each do |key, value|
+        attr = "#{key}="  
+        self.send(attr, value) if self.respond_to?(attr)
+      end
+    end
+
+    # Dynamically create accessors for boolean attriubtes
+    BOOLEAN_ATTRIBUTES.each do |attr|    
+      class_eval %{
+      # The #{attr} attribute reader
+      # @return [Boolean]
+      attr_reader :#{attr} 
+
+      # The #{attr} writer
+      # @param [Boolean] value The value to assign to #{attr}
+      # @return [Boolean]
+      def #{attr}=(value)
+        Axlsx::validate_boolean(value)
+        @#{attr} = value
+      end
+      }
     end
 
+    # Anchor point for worksheet's window.
+    # @return [String]
+    attr_reader :code_name
+
+    # Specifies a stable name of the sheet, which should not change over time,
+    #  and does not change from user input. This name should be used by code 
+    #  to reference a particular sheet.
+    # @return [String]
+    attr_reader :sync_ref
+
+    # The worksheet these properties apply to!
+    # @return [Worksheet]
     attr_reader :worksheet
 
+    # @see code_name
+    # @param [String] name
+    def code_name=(name)
+      @code_name = name
+    end
+
+    # @see sync_ref
+    # @param [String] ref A cell reference (e.g. "A1")
+    def sync_ref=(ref)
+      @sync_ref = ref
+    end
+
     # Serialize the object
     # @param [String] str serialized output will be appended to this object if provided.
     # @return [String]
     def to_xml_string(str = '')
-       return unless worksheet.fit_to_page?
-      str << "<sheetPr><pageSetUpPr fitToPage=\"%s\"></pageSetUpPr></sheetPr>" % worksheet.fit_to_page?
+      update_properties
+      str << "<sheetPr #{serialized_attributes}>"
+      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
+
+    private
+
+    def serialized_attributes(str = '')
+      instance_values.each do |key, value| 
+        unless %(worksheet page_setup_pr).include? key
+          str << "#{Axlsx.camel(key, false)}='#{value}' " 
+        end
+      end
+      str
+    end
+
+    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