rubyXL 1.2.10 → 3.4.33

data/lib/rubyXL/objects/query_table.rb

@@ -0,0 +1,106 @@
+require 'rubyXL/objects/ooxml_object'
+require 'rubyXL/objects/simple_types'
+require 'rubyXL/objects/extensions'
+require 'rubyXL/objects/relationships'
+require 'rubyXL/objects/sheet_common'
+
+# Query Tables
+# https://msdn.microsoft.com/en-us/library/hh643563(v=office.12).aspx
+
+module RubyXL
+  # http://www.datypic.com/sc/ooxml/e-ssml_queryTableField-1.html
+  class QueryTableField < OOXMLObject
+    define_attribute(:id,            :uint, :required => true)
+    define_attribute(:name,          RubyXL::ST_Xstring)
+    define_attribute(:dataBound,     :bool, :default => true)
+    define_attribute(:rowNumbers,    :bool, :default => false)
+    define_attribute(:fillFormulas,  :bool, :default => false)
+    define_attribute(:clipped,       :bool, :default => false)
+    define_attribute(:tableColumnId, :uint, :default => 0)
+
+    define_child_node(RubyXL::ExtensionStorageArea)
+
+    define_element_name 'queryTableField'
+  end
+
+  # http://www.datypic.com/sc/ooxml/e-ssml_queryTableFields-1.html
+  class QueryTableFields < OOXMLObject
+    define_child_node(RubyXL::QueryTableField, :collection => :with_count,
+                      :accessor => :fields, :node_name => :queryTableField)
+    define_element_name 'queryTableFields'
+  end
+
+  # http://www.datypic.com/sc/ooxml/e-ssml_deletedField-1.html
+  class QueryTableDeletedField < OOXMLObject
+    define_attribute(:name, RubyXL::ST_Xstring, :required => true)
+
+    define_element_name 'deletedField'
+  end
+
+  # http://www.datypic.com/sc/ooxml/e-ssml_queryTableDeletedFields-1.html
+  class QueryTableDeletedFields < OOXMLObject
+    define_child_node(RubyXL::QueryTableDeletedField, :collection => :with_count,
+                      :accessor => :deleted_fields, :node_name => :deletedField)
+    define_element_name 'queryTableDeletedFields'
+  end
+
+  # http://www.datypic.com/sc/ooxml/e-ssml_queryTableRefresh-1.html
+  class QueryTableRefresh < OOXMLObject
+    define_attribute(:preserveSortFilterLayout, :bool, :default => true)
+    define_attribute(:fieldIdWrapped,           :bool, :default => false)
+    define_attribute(:headersInLastRefresh,     :bool, :default => true)
+    define_attribute(:minimumVersion,           :uint, :default => 0)
+    define_attribute(:nextId,                   :uint, :default => 1)
+    define_attribute(:unboundColumnsLeft,       :uint, :default => 0)
+    define_attribute(:unboundColumnsRight,      :uint, :default => 0)
+
+    define_child_node(RubyXL::QueryTableFields) # [1..1]
+    define_child_node(RubyXL::QueryTableDeletedFields)
+    define_child_node(RubyXL::SortState)
+    define_child_node(RubyXL::ExtensionStorageArea)
+
+    define_element_name 'queryTableRefresh'
+  end
+
+  # http://www.datypic.com/sc/ooxml/e-ssml_queryTable.html
+  class QueryTable < OOXMLTopLevelObject
+    CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.queryTable+xml'.freeze
+    REL_TYPE     = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/queryTable'.freeze
+
+    include RubyXL::RelationshipSupport
+
+    define_attribute(:name,                    RubyXL::ST_Xstring, :required => true)
+    define_attribute(:headers,                 :bool, :default => true)
+    define_attribute(:rowNumbers,              :bool, :default => false)
+    define_attribute(:disableRefresh,          :bool, :default => false)
+    define_attribute(:backgroundRefresh,       :bool, :default => true)
+    define_attribute(:firstBackgroundRefresh,  :bool, :default => false)
+    define_attribute(:refreshOnLoad,           :bool, :default => false)
+    define_attribute(:growShrinkType,          RubyXL::ST_GrowShrinkType, :default => 'insertDelete')
+    define_attribute(:fillFormulas,            :bool, :default => false)
+    define_attribute(:removeDataOnSave,        :bool, :default => false)
+    define_attribute(:disableEdit,             :bool, :default => false)
+    define_attribute(:preserveFormatting,      :bool, :default => true)
+    define_attribute(:adjustColumnWidth,       :bool, :default => true)
+    define_attribute(:intermediate,            :bool, :default => false)
+    define_attribute(:connectionId,            :uint, :required => true)
+    define_attribute(:autoFormatId,            :uint)
+    define_attribute(:applyNumberFormats,      :bool)
+    define_attribute(:applyBorderFormats,      :bool)
+    define_attribute(:applyFontFormats,        :bool)
+    define_attribute(:applyPatternFormats,     :bool)
+    define_attribute(:applyAlignmentFormats,   :bool)
+    define_attribute(:applyWidthHeightFormats, :bool)
+
+    define_child_node(RubyXL::QueryTableRefresh)
+    define_child_node(RubyXL::ExtensionStorageArea)
+
+    define_element_name 'queryTable'
+    set_namespaces('http://schemas.openxmlformats.org/spreadsheetml/2006/main'           => nil,
+                   'http://schemas.openxmlformats.org/officeDocument/2006/relationships' => 'r')
+
+    def xlsx_path
+      ROOT.join('xl', 'queryTables', "queryTable#{file_index}.xml")
+    end
+  end
+end

data/lib/rubyXL/objects/reference.rb

@@ -0,0 +1,119 @@
+module RubyXL
+  class Reference
+    ROW_MAX = 1024 * 1024
+    COL_MAX = 16393
+
+    attr_reader :row_range, :col_range
+
+    # RubyXL::Reference.new(row, col)
+    # RubyXL::Reference.new(row_from, row_to, col_from, col_to)
+    # RubyXL::Reference.new(reference_string)
+    # RubyXL::Reference.new(row_from:, row_to:, col_from:, col_to:)
+    def initialize(*params)
+      row_from = row_to = col_from = col_to = nil
+
+      case params.size
+      when 4 then row_from, row_to, col_from, col_to = params
+      when 2 then row_from, col_from = params
+      when 1 then
+        case params.first
+        when Hash then
+          row_from, row_to, col_from, col_to = params.first.fetch_values(:row_from, :row_to, :col_from, :col_to)
+        when String then
+          from, to = params[0].split(':')
+          row_from, col_from = self.class.ref2ind(from)
+          row_to, col_to = self.class.ref2ind(to) unless to.nil?
+        else
+          raise ArgumentError.new("invalid value for #{self.class}: #{params[0].inspect}") unless params[0].is_a?(String)
+        end
+      end
+
+      @row_range = Range.new(row_from || 0, row_to || row_from || ROW_MAX)
+      @col_range = Range.new(col_from || 0, col_to || col_from || COL_MAX)
+    end
+
+    def single_cell?
+      (@row_range.begin == @row_range.end) && (@col_range.begin == @col_range.end)
+    end
+
+    def valid?
+      !(row_range.begin.negative? || col_range.begin.negative?)
+    end
+
+    def first_row
+      @row_range.begin
+    end
+
+    def last_row
+      @row_range.end
+    end
+
+    def first_col
+      @col_range.begin
+    end
+
+    def last_col
+      @col_range.end
+    end
+
+    def ==(other)
+      !other.nil? && (@row_range == other.row_range) && (@col_range == other.col_range)
+    end
+
+    def cover?(other)
+      !other.nil? && (@row_range.cover?(other.row_range.begin) &&
+                      @row_range.cover?(other.row_range.end) &&
+                      @col_range.cover?(other.col_range.begin) &&
+                      @col_range.cover?(other.col_range.end))
+    end
+
+    def to_s
+      if single_cell? then
+        self.class.ind2ref(@row_range.begin, @col_range.begin)
+      else
+        self.class.ind2ref(@row_range.begin, @col_range.begin) + ':' +
+                           self.class.ind2ref(@row_range.end, @col_range.end)
+      end
+    end
+
+    def inspect
+      if single_cell? then
+        "#<#{self.class} @row=#{@row_range.begin} @col=#{@col_range.begin}>"
+      else
+        "#<#{self.class} @row_range=#{@row_range} @col_range=#{@col_range}>"
+      end
+    end
+
+    # Converts +row+ and +col+ zero-based indices to Excel-style cell reference
+    # <0> A...Z, AA...AZ, BA... ...ZZ, AAA... ...AZZ, BAA... ...XFD <16383>
+    def self.ind2ref(row = 0, col = 0)
+      str = ''
+
+      loop do
+        x = col % 26
+        str = ('A'.ord + x).chr + str
+        col = (col / 26).floor - 1
+        break if col < 0
+      end
+
+      str += (row + 1).to_s
+    end
+
+    # Converts Excel-style cell reference to +row+ and +col+ zero-based indices.
+    def self.ref2ind(str)
+      return [ -1, -1 ] unless str =~ /\A([A-Z]+)(\d+)\Z/
+      [ Regexp.last_match(2).to_i - 1,
+        Regexp.last_match(1).each_byte.inject(0) { |col, chr| (col * 26) + (chr - 64) } - 1 ]
+    end
+  end
+
+  class Sqref < Array
+    def initialize(str)
+      str.split.each { |ref_str| self << RubyXL::Reference.new(ref_str) }
+    end
+
+    def to_s
+      self.collect(&:to_s).join(' ')
+    end
+  end
+end

data/lib/rubyXL/objects/relationships.rb

@@ -0,0 +1,213 @@
+require 'pathname'
+require 'rubyXL/objects/ooxml_object'
+
+module RubyXL
+  class RID < OOXMLObject
+    define_relationship(:required => true)
+  end
+
+  class Relationship < OOXMLObject
+    define_attribute(:Id,         :string)
+    define_attribute(:Type,       :string)
+    define_attribute(:Target,     :string)
+    define_attribute(:TargetMode, :string)
+    define_element_name 'Relationship'
+  end
+
+  class OOXMLRelationshipsFile < OOXMLTopLevelObject
+    CONTENT_TYPE = 'application/vnd.openxmlformats-package.relationships+xml'.freeze
+    SAVE_ORDER = 100
+
+    define_child_node(RubyXL::Relationship, :collection => true, :accessor => :relationships)
+    define_element_name 'Relationships'
+    set_namespaces('http://schemas.openxmlformats.org/package/2006/relationships' => nil)
+
+    attr_accessor :related_files, :owner
+
+    @@debug_indent = ($DEBUG ? 0 : nil)
+
+    def new_relationship(target, type)
+      RubyXL::Relationship.new(:id     => "rId#{relationships.size + 1}",
+                               :type   => type,
+                               :target => target)
+    end
+    protected :new_relationship
+
+    def add_relationship(obj)
+      return if obj.nil? || !defined?(obj.class::REL_TYPE) || (obj.respond_to?(:empty?) && obj.empty?)
+
+      relationships << RubyXL::Relationship.new(:id     => "rId#{relationships.size + 1}",
+                                                :type   => obj.class::REL_TYPE,
+                                                :target => obj.xlsx_path.relative_path_from(owner.xlsx_path.dirname))
+    end
+    protected :add_relationship
+
+    def find_by_rid(r_id)
+      relationships.find { |r| r.id == r_id }
+    end
+
+    def find_by_target(target)
+      relationships.find { |r|
+        (r.target == target) || (r.target == target.relative_path_from(owner.xlsx_path.dirname))
+      }
+    end
+
+    def self.get_class_by_rel_type(rel_type)
+      unless defined?(@@rel_hash)
+        @@rel_hash = {}
+        RubyXL.constants.each { |c|
+          klass = RubyXL.const_get(c)
+
+          if klass.is_a?(Class) && klass.const_defined?(:REL_TYPE) then
+            @@rel_hash[klass::REL_TYPE] = klass
+          end
+        }
+      end
+
+      @@rel_hash[rel_type]
+    end
+
+    def load_related_files(zipdir_path, base_file_name)
+      self.related_files = {}
+
+      @@debug_indent += 2 if @@debug_indent
+
+      self.relationships.each { |rel|
+        next if rel.target_mode == 'External'
+
+        file_path = ::Pathname.new(rel.target)
+        file_path = (base_file_name.dirname + file_path).cleanpath if file_path.relative?
+
+        klass = RubyXL::OOXMLRelationshipsFile.get_class_by_rel_type(rel.type)
+
+        if klass.nil? then
+          if !RubyXL.class_variable_get(:@@suppress_warnings) then
+            puts "*** WARNING: storage class not found for #{rel.target} (#{rel.type})"
+          end
+
+          klass = GenericStorageObject
+        end
+
+        puts "--> DEBUG:#{'  ' * @@debug_indent}Loading #{klass} (#{rel.id}): #{file_path}" if @@debug_indent
+
+        obj = klass.parse_file(zipdir_path, file_path)
+        obj.load_relationships(zipdir_path, file_path) if obj.respond_to?(:load_relationships)
+        self.related_files[rel.id] = obj
+      }
+
+      @@debug_indent -= 2 if @@debug_indent
+
+      related_files
+    end
+
+    def self.load_relationship_file(zipdir_path, base_file_path)
+      rel_file_path = rel_file_path(base_file_path)
+
+      puts "--> DEBUG:  #{'  ' * @@debug_indent}Loading .rel file: #{rel_file_path}" if @@debug_indent
+
+      parse_file(zipdir_path, rel_file_path)
+    end
+
+    def xlsx_path
+      self.class.rel_file_path(owner.xlsx_path)
+    end
+
+    def before_write_xml
+      case owner
+      when RubyXL::WorkbookRoot, RubyXL::Workbook then
+        # Fully implemented objects with no generic (unhandled) relationships -
+        #   (re)generating relationships from scratch.
+        related_objects = owner.related_objects
+        related_objects += owner.generic_storage if owner.generic_storage
+
+        self.relationships = []
+        related_objects.compact.each { |f| add_relationship(f) }
+      end
+      super
+    end
+
+    def self.rel_file_path(base_file_path)
+      basename = base_file_path.root? ? '' : base_file_path.basename
+      base_file_path.dirname.join('_rels', "#{basename}.rels").cleanpath
+    end
+  end
+
+  # +RelationshipSupport+ module enables automatic loading and saving of _rels for the respective file
+  module RelationshipSupport
+    module ClassMehods
+      def define_relationship(klass, accessor = nil)
+        class_variable_get(:@@ooxml_relationships)[klass] = accessor
+        attr_accessor(accessor) if accessor
+      end
+    end
+
+    def self.included(klass)
+      klass.class_variable_set(:@@ooxml_relationships, {})
+      klass.extend RubyXL::RelationshipSupport::ClassMehods
+    end
+
+    attr_accessor :generic_storage, :relationship_container
+
+    def related_objects # Override this method
+      []
+    end
+
+    def collect_related_objects
+      res = related_objects.compact # Avoid tainting +related_objects+ array
+      res.concat(generic_storage) if generic_storage
+
+      if relationship_container then
+        relationship_container.owner = self
+        res << relationship_container
+      end
+
+      related = []
+
+      res.each { |obj|
+        next if obj.respond_to?(:empty?) && obj.empty?
+        related << obj
+        related.concat(obj.collect_related_objects) if obj.respond_to?(:collect_related_objects)
+      }
+
+      related
+    end
+
+    def load_relationships(dir_path, base_file_name)
+      self.relationship_container = RubyXL::OOXMLRelationshipsFile.load_relationship_file(dir_path, base_file_name)
+      return if relationship_container.nil?
+
+      relationship_container.load_related_files(dir_path, base_file_name).each_pair { |rid, related_file|
+        attach_relationship(rid, related_file) if related_file
+      }
+    end
+
+    def attach_relationship(rid, rf)
+      relationships = self.class.class_variable_get(:@@ooxml_relationships)
+      klass = rf.class
+      if relationships.has_key?(klass) then
+        accessor = relationships[klass]
+        case accessor
+        when NilClass then
+          # Relationship is known, but we don't have a special accessor for it, store as generic
+          store_relationship(rf)
+        when false then
+          # Do nothing, the code will perform attaching on its own
+        else
+          container = self.send(accessor)
+          if container.is_a?(Array) then container << rf
+          else self.send("#{accessor}=", rf)
+          end
+        end
+      else store_relationship(rf, :unknown)
+      end
+    end
+
+    def store_relationship(related_file, unknown = false)
+      self.generic_storage ||= []
+      if unknown && !RubyXL.class_variable_get(:@@suppress_warnings) then
+        puts "WARNING: #{self.class} is not aware how to process #{related_file.class}"
+      end
+      self.generic_storage << related_file
+    end
+  end
+end

data/lib/rubyXL/objects/root.rb

@@ -0,0 +1,84 @@
+require 'zip'
+require 'rubyXL/objects/relationships'
+require 'rubyXL/objects/document_properties'
+require 'rubyXL/objects/content_types'
+require 'rubyXL/objects/workbook'
+
+module RubyXL
+  class WorkbookRoot
+    @@debug = $DEBUG
+
+    attr_accessor :source_file_path, :content_types, :rels_hash
+
+    include RubyXL::RelationshipSupport
+
+    define_relationship(RubyXL::ThumbnailFile,          :thumbnail)
+    define_relationship(RubyXL::CorePropertiesFile,     :core_properties)
+    define_relationship(RubyXL::DocumentPropertiesFile, :document_properties)
+    define_relationship(RubyXL::CustomPropertiesFile,   :custom_properties)
+    define_relationship(RubyXL::Workbook,               :workbook)
+
+    def related_objects
+      [ content_types, thumbnail, core_properties, document_properties, custom_properties, workbook ]
+    end
+
+    def self.default
+      obj = self.new
+      obj.document_properties    = RubyXL::DocumentPropertiesFile.new
+      obj.core_properties        = RubyXL::CorePropertiesFile.new
+      obj.relationship_container = RubyXL::OOXMLRelationshipsFile.new
+      obj.content_types          = RubyXL::ContentTypes.new
+      obj
+    end
+
+    # Write <tt>.xlsx</tt> to a stream (useful for sending over HTTP)
+    def stream
+      stream = Zip::OutputStream.write_buffer { |zipstream|
+        self.rels_hash = {}
+        self.relationship_container.owner = self
+        collect_related_objects.compact.each { |obj|
+          puts "<-- DEBUG: adding relationship to #{obj.class}" if @@debug
+          obj.root = self if obj.respond_to?(:root=)
+          self.rels_hash[obj.class] ||= []
+          self.rels_hash[obj.class] << obj
+        }
+
+        self.rels_hash.keys.sort_by{ |c| c::SAVE_ORDER }.each { |klass|
+          puts "<-- DEBUG: saving related #{klass} files" if @@debug
+          self.rels_hash[klass].select! { |obj|
+            puts "<-- DEBUG:   > #{obj.xlsx_path}" if @@debug
+            obj.add_to_zip(zipstream)
+          }
+        }
+      }
+      stream.rewind
+      stream
+    end
+
+    def xlsx_path
+      OOXMLTopLevelObject::ROOT
+    end
+
+    def self.parse_zip_file(zip_file)
+      root = self.new
+      root.content_types = RubyXL::ContentTypes.parse_file(zip_file, ContentTypes::XLSX_PATH)
+      root.load_relationships(zip_file, OOXMLTopLevelObject::ROOT)
+
+      wb = root.workbook
+      wb.root = root
+
+      wb.sheets.each_with_index { |sheet, i|
+        sheet_obj = wb.relationship_container.related_files[sheet.r_id]
+
+        wb.worksheets[i] = sheet_obj # Must be done first so the sheet becomes aware of its number
+        sheet_obj.workbook = wb
+
+        sheet_obj.sheet_name = sheet.name
+        sheet_obj.sheet_id = sheet.sheet_id
+        sheet_obj.state = sheet.state
+      }
+
+      root
+    end
+  end
+end

data/lib/rubyXL/objects/shared_strings.rb

@@ -0,0 +1,67 @@
+require 'rubyXL/objects/ooxml_object'
+require 'rubyXL/objects/text'
+require 'rubyXL/objects/extensions'
+
+module RubyXL
+  # http://www.datypic.com/sc/ooxml/e-ssml_sst.html
+  class SharedStringsTable < OOXMLTopLevelObject
+    CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml'.freeze
+    REL_TYPE     = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings'.freeze
+
+    # According to http://msdn.microsoft.com/en-us/library/office/gg278314.aspx,
+    # +count+ and +uniqueCount+ may be either both missing, or both present. Need to validate.
+    define_attribute(:uniqueCount, :int)
+    define_child_node(RubyXL::RichText, :collection => :with_count, :node_name => 'si', :accessor => :strings)
+    define_child_node(RubyXL::ExtensionStorageArea)
+    define_element_name 'sst'
+    set_namespaces('http://schemas.openxmlformats.org/spreadsheetml/2006/main' => nil)
+
+    def initialize(*params)
+      super
+      # So far, going by the structure that the original creator had in mind. However,
+      # since the actual implementation is now extracted into a separate class,
+      # we will be able to transparently change it later if needs be.
+      @index_by_content = {}
+    end
+
+    def before_write_xml
+      super
+      self.unique_count = self.count
+      self.count > 0
+    end
+
+    def [](index)
+      strings[index]
+    end
+
+    def empty?
+      strings.empty?
+    end
+
+    def add(v, index = nil)
+      index ||= strings.size
+
+      strings[index] =
+        case v
+        when RubyXL::RichText then v
+        when String then RubyXL::RichText.new(:t => RubyXL::Text.new(:value => v))
+        when RubyXL::Text               then RubyXL::RichText.new(:t => v)
+        when RubyXL::RichTextRun        then RubyXL::RichText.new(:r => [ v ])
+        when RubyXL::PhoneticRun        then RubyXL::RichText.new(:r_ph => [ v ])
+        when RubyXL::PhoneticProperties then RubyXL::RichText.new(:phonetic_pr => v)
+        end
+
+      @index_by_content[v.to_s] = index
+    end
+
+    def get_index(str, add_if_missing = false)
+      index = @index_by_content[str]
+      index = add(str) if index.nil? && add_if_missing
+      index
+    end
+
+    def xlsx_path
+      ROOT.join('xl', 'sharedStrings.xml')
+    end
+  end
+end

data/lib/rubyXL/objects/sheet_common.rb

@@ -0,0 +1,49 @@
+require 'rubyXL/objects/ooxml_object'
+require 'rubyXL/objects/storage'
+
+module RubyXL
+  # http://www.datypic.com/sc/ooxml/e-ssml_webPublishItem-1.html
+  class WebPublishingItem < OOXMLObject
+    define_attribute(:id,              :int,    :required => true)
+    define_attribute(:divId,           :int,    :required => true)
+    define_attribute(:sourceType,      RubyXL::ST_WebSourceType, :required => true)
+    define_attribute(:sourceRef,       :ref)
+    define_attribute(:sourceObject,    :string)
+    define_attribute(:destinationFile, :string, :required => true)
+    define_attribute(:title,           :string)
+    define_attribute(:autoRepublish,   :bool, :default => false)
+    define_element_name 'webPublishItem'
+  end
+
+  # http://www.datypic.com/sc/ooxml/e-ssml_webPublishItems-1.html
+  class WebPublishingItems < OOXMLContainerObject
+    define_child_node(RubyXL::WebPublishingItem, :collection => :with_count)
+    define_element_name 'webPublishItems'
+  end
+
+  # http://www.datypic.com/sc/ooxml/e-ssml_pageMargins-1.html
+  class PageMargins < OOXMLObject
+    define_attribute(:left,   :double, :required => true)
+    define_attribute(:right,  :double, :required => true)
+    define_attribute(:top,    :double, :required => true)
+    define_attribute(:bottom, :double, :required => true)
+    define_attribute(:header, :double, :required => true)
+    define_attribute(:footer, :double, :required => true)
+    define_element_name 'pageMargins'
+  end
+
+  # http://www.datypic.com/sc/ooxml/e-ssml_headerFooter-1.html
+  class HeaderFooterSettings < OOXMLObject
+    define_attribute(:differentOddEven, :bool, :default => false)
+    define_attribute(:differentFirst,   :bool, :default => false)
+    define_attribute(:scaleWithDoc,     :bool, :default => true)
+    define_attribute(:alignWithMargins, :bool, :default => true)
+    define_child_node(RubyXL::StringNode, :node_name => :oddHeader)
+    define_child_node(RubyXL::StringNode, :node_name => :oddFooter)
+    define_child_node(RubyXL::StringNode, :node_name => :evenHeader)
+    define_child_node(RubyXL::StringNode, :node_name => :evenFooter)
+    define_child_node(RubyXL::StringNode, :node_name => :firstHeader)
+    define_child_node(RubyXL::StringNode, :node_name => :firstFooter)
+    define_element_name 'headerFooter'
+  end
+end