keeguon-spreadsheet 0.9.3

data/lib/spreadsheet/excel/writer/workbook.rb

@@ -0,0 +1,735 @@
+require 'spreadsheet/excel/internals'
+require 'spreadsheet/writer'
+require 'spreadsheet/excel/writer/biff8'
+require 'spreadsheet/excel/writer/format'
+require 'spreadsheet/excel/writer/worksheet'
+require 'ole/storage'
+
+module Spreadsheet
+  module Excel
+    module Writer
+##
+# Writer class for Excel Workbooks. Most write_* method correspond to an
+# Excel-Record/Opcode. Designed to be able to write several Workbooks in
+# parallel (just because I can't imagine why you would want to do that
+# doesn't mean it shouldn't be possible ;). You should not need to call any of
+# its methods directly. If you think you do, look at #write_workbook
+class Workbook < Spreadsheet::Writer
+  include Spreadsheet::Excel::Writer::Biff8
+  include Spreadsheet::Excel::Internals
+  attr_reader :fonts, :date_base
+  def initialize *args
+    super
+    @biff_version = 0x0600
+    @bof = 0x0809
+    @build_id = 3515
+    @build_year = 1996
+    @bof_types = {
+      :globals      => 0x0005,
+      :visual_basic => 0x0006,
+      :worksheet    => 0x0010,
+      :chart        => 0x0020,
+      :macro_sheet  => 0x0040,
+      :workspace    => 0x0100,
+    }
+    @worksheets = {}
+    @sst = {}
+    @recordsize_limit = 8224
+    @fonts = {}
+    @formats = {}
+    @number_formats = {}
+  end
+  def cleanup workbook
+    worksheets(workbook).each do |worksheet|
+      @sst.delete worksheet
+    end
+    @fonts.delete workbook
+    @formats.delete workbook
+    @number_formats.delete workbook
+    @worksheets.delete workbook
+  end
+  def collect_formats workbook, opts={}
+    # The default cell format is always present in an Excel file, described by
+    # the XF record with the fixed index 15 (0-based). By default, it uses the
+    # worksheet/workbook default cell style, described by the very first XF
+    # record (index 0).
+    formats = []
+    unless opts[:existing_document]
+      15.times do
+        formats.push Format.new(self, workbook, workbook.default_format,
+                                :type => :style)
+      end
+      formats.push Format.new(self, workbook)
+    end
+    workbook.formats.each do |fmt|
+      formats.push Format.new(self, workbook, fmt)
+    end
+    @formats[workbook] = {
+      :writers => [],
+      :xf_indexes => {}
+    }
+    formats.each_with_index do |fmt, idx|
+      @formats[workbook][:writers] << fmt
+      @formats[workbook][:xf_indexes][fmt.format] ||= idx
+    end
+  end
+  def complete_sst_update? workbook
+    stored = workbook.sst.collect do |entry| entry.content end
+    num_total = 0
+    current = worksheets(workbook).inject(Hash.new(0)) do |memo, worksheet|
+      worksheet.strings.each do |k,v|
+        memo[k] += v
+        num_total += v
+      end
+      memo
+    end
+    current.delete ''
+    if !stored.empty? && stored.all?{|x| current.include?(x) }
+      ## if all previously stored strings are still needed, we don't have to
+      #  rewrite all cells because the sst-index of such string does not change.
+      additions = current.keys - stored
+      [:partial_update, num_total, stored + additions]
+    else
+      [:complete_update, num_total, current.keys]
+    end
+  end
+  def font_index workbook, font_key
+    idx = @fonts[workbook][font_key] || 0
+    ## this appears to be undocumented: the first 4 fonts seem to be accessed
+    #  with a 0-based index, but all subsequent font indices are 1-based.
+    idx > 3 ? idx.next : idx
+  end
+  def number_format_index workbook, format
+    @number_formats[workbook][format] || 0
+  end
+  def sanitize_worksheets sheets
+    return sheets if sheets.empty?
+    found_selected = false
+    sheets.each do |sheet|
+      found_selected ||= sheet.selected
+      sheet.format_dates!
+    end
+    unless found_selected
+      sheets.first.selected = true
+    end
+    sheets
+  end
+  def worksheets workbook
+    @worksheets[workbook] ||= workbook.worksheets.collect do |worksheet|
+      Excel::Writer::Worksheet.new self, worksheet
+    end
+  end
+  def write_bof workbook, writer, type
+    data = [
+      @biff_version,    # BIFF version (always 0x0600 for BIFF8)
+      @bof_types[type], # Type of the following data:
+                        # 0x0005 = Workbook globals
+                        # 0x0006 = Visual Basic module
+                        # 0x0010 = Worksheet
+                        # 0x0020 = Chart
+                        # 0x0040 = Macro sheet
+                        # 0x0100 = Workspace file
+      @build_id,        # Build identifier
+      @build_year,      # Build year
+      0x000,            # File history flags
+      0x006,            # Lowest Excel version that can read
+                        # all records in this file
+    ]
+    write_op writer, @bof, data.pack("v4V2")
+  end
+  def write_bookbool workbook, writer
+    write_placeholder writer, 0x00da
+  end
+  def write_boundsheets workbook, writer, offset
+    worksheets = worksheets(workbook)
+    worksheets.each do |worksheet|
+      # account for boundsheet-entry
+      offset += worksheet.boundsheet_size
+    end
+    worksheets.each do |worksheet|
+      visibility = SEITILIBISIV_TEEHSKROW[worksheet.worksheet.visibility]
+      data = [
+        offset,   # Absolute stream position of the BOF record of the sheet
+                  # represented by this record. This field is never encrypted
+                  # in protected files.
+        visibility,     # Visibility: 0x00 = Visible
+                  #             0x01 = Hidden
+                  #             0x02 = Strong hidden (see below)
+        0x00,     # Sheet type: 0x00 = Worksheet
+                  #             0x02 = Chart
+                  #             0x06 = Visual Basic module
+      ]
+      write_op writer, 0x0085, data.pack("VC2"), worksheet.name
+      offset += worksheet.size
+    end
+  end
+  ##
+  # Copy unchanged data verbatim, adjust offsets and write new records for
+  # changed data.
+  def write_changes workbook, io
+    sanitize_worksheets workbook.worksheets
+    collect_formats workbook, :existing_document => true
+    reader = workbook.ole
+    sheet_data = {}
+    sst_status, sst_total, sst_strings = complete_sst_update? workbook
+    sst = {}
+    sst_strings.each_with_index do |str, idx| sst.store str, idx end
+    sheets = worksheets(workbook)
+    positions = []
+    newsheets = []
+    sheets.each do |sheet|
+      @sst[sheet] = sst
+      pos, len = workbook.offsets[sheet.worksheet]
+      if pos
+        positions.push pos
+        sheet.write_changes reader, pos + len, sst_status
+      else
+        newsheets.push sheet
+        sheet.write_from_scratch
+      end
+      sheet_data[sheet.worksheet] = sheet.data
+    end
+    Ole::Storage.open io do |ole|
+      ole.file.open 'Workbook', 'w' do |writer|
+        reader.seek lastpos = 0
+        workbook.offsets.select do |key, pair|
+          workbook.changes.include? key
+        end.sort_by do |key, (pos, _)|
+          pos
+        end.each do |key, (pos, len)|
+          data = reader.read(pos - lastpos)
+          writer.write data
+          case key
+          when Spreadsheet::Worksheet
+            writer.write sheet_data[key]
+          when :boundsheets
+            ## boundsheets are hard to calculate. The offset below is only
+            #  correct if there are no more changes in the workbook globals
+            #  string after this.
+            oldoffset = positions.min - len
+            lastpos = pos + len
+            bytechange = 0
+            buffer = StringIO.new ''
+            if tuple = workbook.offsets[:sst]
+              write_sst_changes workbook, buffer, writer.pos,
+                                sst_total, sst_strings
+              pos, len = tuple
+              if offset = workbook.offsets[:extsst]
+                len += offset[1].to_i
+              end
+              bytechange = buffer.size - len
+              write_boundsheets workbook, writer, oldoffset + bytechange
+              reader.seek lastpos
+              writer.write reader.read(pos - lastpos)
+              buffer.rewind
+              writer.write buffer.read
+            elsif sst.empty? || workbook.biff_version < 8
+              write_boundsheets workbook, writer, oldoffset + bytechange
+            else
+              write_sst workbook, buffer, writer.pos
+              write_boundsheets workbook, writer, oldoffset + buffer.size
+              pos = lastpos
+              len = positions.min - lastpos
+              if len > OPCODE_SIZE
+                reader.seek pos
+                writer.write reader.read(len - OPCODE_SIZE)
+              end
+              buffer.rewind
+              writer.write buffer.read
+              write_eof workbook, writer
+            end
+          else
+            send "write_#{key}", workbook, writer
+          end
+          lastpos = [pos + len, reader.size - 1].min
+          reader.seek lastpos
+        end
+        writer.write reader.read
+        newsheets.each do |sheet|
+          writer.write sheet.data
+        end
+      end
+    end
+  end
+  def write_datemode workbook, writer
+    mode = @date_base.year == 1899 ? 0x00 : 0x01
+    data = [
+      mode, # 0 = Base date is 1899-Dec-31
+            #     (the cell value 1 represents 1900-Jan-01)
+            # 1 = Base date is 1904-Jan-01
+            #     (the cell value 1 represents 1904-Jan-02)
+    ]
+    write_op writer, 0x0022, data.pack('v')
+  end
+  def write_dsf workbook, writer
+    data = [
+      0x00, # 0 = Only the BIFF8 “Workbook” stream is present
+            # 1 = Additional BIFF5/BIFF7 “Book” stream is in the file
+    ]
+    write_op writer, 0x0161, data.pack('v')
+  end
+  def write_encoding workbook, writer
+    enc = workbook.encoding || 'UTF-16LE'
+    if RUBY_VERSION >= '1.9' && enc.is_a?(Encoding)
+      enc = enc.name.upcase
+    end
+    cp = SEGAPEDOC[enc] or raise "Invalid or Unknown Codepage '#{enc}'"
+    write_op writer, 0x0042, [cp].pack('v')
+  end
+  def write_eof workbook, writer
+    write_op writer, 0x000a
+  end
+  def write_extsst workbook, offsets, writer
+    header = [SST_CHUNKSIZE].pack('v')
+    data = offsets.collect do |pair| pair.push(0).pack('Vv2') end
+    write_op writer, 0x00ff, header, data
+  end
+  def write_font workbook, writer, font
+    # TODO: Colors/Palette index
+    size      = font.size * TWIPS
+    color     = SEDOC_ROLOC[font.color] || SEDOC_ROLOC[:text]
+    weight    = FONT_WEIGHTS.fetch(font.weight, font.weight)
+    weight    = [[weight, 1000].min, 100].max
+    esc       = SEPYT_TNEMEPACSE.fetch(font.escapement, 0)
+    underline = SEPYT_ENILREDNU.fetch(font.underline, 0)
+    family    = SEILIMAF_TNOF.fetch(font.family, 0)
+    encoding  = SGNIDOCNE_TNOF.fetch(font.encoding, 0)
+    options   = 0
+    options  |= 0x0001 if weight > 600
+    options  |= 0x0002 if font.italic?
+    options  |= 0x0004 if underline > 0
+    options  |= 0x0008 if font.strikeout?
+    options  |= 0x0010 if font.outline?
+    options  |= 0x0020 if font.shadow?
+    data = [
+      size,     # Height of the font (in twips = 1/20 of a point)
+      options,  # Option flags:
+                # Bit  Mask    Contents
+                #   0  0x0001  1 = Characters are bold (redundant, see below)
+                #   1  0x0002  1 = Characters are italic
+                #   2  0x0004  1 = Characters are underlined (redundant)
+                #   3  0x0008  1 = Characters are struck out
+                #   4  0x0010  1 = Characters are outlined (djberger)
+                #   5  0x0020  1 = Characters are shadowed (djberger)
+      color,    # Palette index (➜ 6.70)
+      weight,   # Font weight (100-1000). Standard values are
+                #      0x0190 (400) for normal text and
+                #      0x02bc (700) for bold text.
+      esc,      # Escapement type: 0x0000 = None
+                #                  0x0001 = Superscript
+                #                  0x0002 = Subscript
+      underline,# Underline type:  0x00 = None
+                #                  0x01 = Single
+                #                  0x02 = Double
+                #                  0x21 = Single accounting
+                #                  0x22 = Double accounting
+      family,   # Font family:     0x00 = None (unknown or don't care)
+                #                  0x01 = Roman (variable width, serifed)
+                #                  0x02 = Swiss (variable width, sans-serifed)
+                #                  0x03 = Modern (fixed width,
+                #                                 serifed or sans-serifed)
+                #                  0x04 = Script (cursive)
+                #                  0x05 = Decorative (specialised,
+                #                                       e.g. Old English, Fraktur)
+      encoding, # Character set: 0x00 =   0 = ANSI Latin
+                #                0x01 =   1 = System default
+                #                0x02 =   2 = Symbol
+                #                0x4d =  77 = Apple Roman
+                #                0x80 = 128 = ANSI Japanese Shift-JIS
+                #                0x81 = 129 = ANSI Korean (Hangul)
+                #                0x82 = 130 = ANSI Korean (Johab)
+                #                0x86 = 134 = ANSI Chinese Simplified GBK
+                #                0x88 = 136 = ANSI Chinese Traditional BIG5
+                #                0xa1 = 161 = ANSI Greek
+                #                0xa2 = 162 = ANSI Turkish
+                #                0xa3 = 163 = ANSI Vietnamese
+                #                0xb1 = 177 = ANSI Hebrew
+                #                0xb2 = 178 = ANSI Arabic
+                #                0xba = 186 = ANSI Baltic
+                #                0xcc = 204 = ANSI Cyrillic
+                #                0xde = 222 = ANSI Thai
+                #                0xee = 238 = ANSI Latin II (Central European)
+                #                0xff = 255 = OEM Latin I
+    ]
+    name = unicode_string font.name # Font name: Unicode string,
+                                    # 8-bit string length (➜ 3.4)
+    write_op writer, opcode(:font), data.pack(binfmt(:font)), name
+  end
+  def write_fonts workbook, writer
+    fonts = @fonts[workbook] = {}
+    @formats[workbook][:writers].map{|format| format.font }.compact.uniq.each do |font|
+      unless fonts.include?(font.key)
+        fonts.store font.key, fonts.size
+        write_font workbook, writer, font
+      end
+    end
+  end
+  def write_formats workbook, writer
+    # From BIFF5 on, the built-in number formats will be omitted. The built-in
+    # formats are dependent on the current regional settings of the operating
+    # system. BUILTIN_FORMATS shows which number formats are used by
+    # default in a US-English environment. All indexes from 0 to 163 are
+    # reserved for built-in formats.
+    # The first user-defined format starts at 164 (0xa4).
+    formats = @number_formats[workbook] = {}
+    BUILTIN_FORMATS.each do |idx, str|
+      formats.store client(str, 'UTF-8'), idx
+    end
+    ## Ensure at least a 'GENERAL' format is written
+    formats.delete client('GENERAL', 'UTF-8')
+    idx = 0xa4
+    workbook.formats.each do |fmt|
+      str = fmt.number_format
+      unless formats[str]
+        formats.store str, idx
+        # Number format string (Unicode string, 16-bit string length, ➜ 3.4)
+        write_op writer, opcode(:format), [idx].pack('v'), unicode_string(str, 2)
+        idx += 1
+      end
+    end
+  end
+  ##
+  # Write a new Excel file.
+  def write_from_scratch workbook, io
+    sanitize_worksheets workbook.worksheets
+    collect_formats workbook
+    sheets = worksheets workbook
+    buffer1 = StringIO.new ''
+    # ●  BOF Type = workbook globals (➜ 6.8)
+    write_bof workbook, buffer1, :globals
+    # ○  File Protection Block ➜ 4.19
+    # ○  WRITEACCESS User name (BIFF3-BIFF8, ➜ 5.112)
+    # ○  FILESHARING File sharing options (BIFF3-BIFF8, ➜ 5.44)
+    # ○  CODEPAGE ➜ 6.17
+    write_encoding workbook, buffer1
+    # ○  DSF ➜ 6.32
+    write_dsf workbook, buffer1
+    # ○  TABID
+    write_tabid workbook, buffer1
+    # ○  FNGROUPCOUNT
+    # ○  Workbook Protection Block ➜ 4.18
+    # ○  WINDOWPROTECT Window settings: 1 = protected (➜ 5.111)
+    # ○  PROTECT Cell contents: 1 = protected (➜ 5.82)
+    write_protect workbook, buffer1
+    # ○  OBJECTPROTECT Embedded objects: 1 = protected (➜ 5.72)
+    # ○  PASSWORD Hash value of the password; 0 = No password (➜ 5.76)
+    write_password workbook, buffer1
+    # ○  BACKUP ➜ 5.5
+    # ○  HIDEOBJ ➜ 5.56
+    # ●  WINDOW1 ➜ 5.109
+    write_window1 workbook, buffer1
+    # ○  DATEMODE ➜ 5.28
+    write_datemode workbook, buffer1
+    # ○  PRECISION ➜ 5.79
+    write_precision workbook, buffer1
+    # ○  REFRESHALL
+    write_refreshall workbook, buffer1
+    # ○  BOOKBOOL ➜ 5.9
+    write_bookbool workbook, buffer1
+    # ●● FONT ➜ 5.45
+    write_fonts workbook, buffer1
+    # ○○ FORMAT ➜ 5.49
+    write_formats workbook, buffer1
+    # ●● XF ➜ 5.115
+    write_xfs workbook, buffer1
+    # ●● STYLE ➜ 5.103
+    write_styles workbook, buffer1
+    # ○  PALETTE ➜ 5.74
+    write_palette workbook, buffer1
+    # ○  USESELFS ➜ 5.106
+    buffer1.rewind
+    # ●● BOUNDSHEET ➜ 5.95
+    buffer2 = StringIO.new ''
+    # ○  COUNTRY ➜ 5.22
+    # ○  Link Table ➜ 4.10.3
+    # ○○ NAME ➜ 6.66
+    # ○  Shared String Table ➜ 4.11
+    # ●  SST ➜ 5.100
+    # ●  EXTSST ➜ 5.42
+    write_sst workbook, buffer2, buffer1.size
+    # ●  EOF ➜ 5.37
+    write_eof workbook, buffer2
+    buffer2.rewind
+    # worksheet data can only be assembled after write_sst
+    sheets.each do |worksheet| worksheet.write_from_scratch end
+    Ole::Storage.open io do |ole|
+      ole.file.open 'Workbook', 'w' do |writer|
+        writer.write buffer1.read
+        write_boundsheets workbook, writer, buffer1.size + buffer2.size
+        writer.write buffer2.read
+        sheets.each do |worksheet|
+          writer.write worksheet.data
+        end
+      end
+    end
+  end
+  def write_op writer, op, *args
+    data = args.join
+    limited = data.slice!(0...@recordsize_limit)
+    writer.write [op,limited.size].pack("v2")
+    writer.write limited
+    data
+  end
+  def write_password workbook, writer
+    write_placeholder writer, 0x0013
+  end
+  def write_placeholder writer, op, value=0x0000, fmt='v'
+    write_op writer, op, [value].pack(fmt)
+  end
+  def write_precision workbook, writer
+    # 0 = Use displayed values; 1 = Use real cell values
+    write_placeholder writer, 0x000e, 0x0001
+  end
+  def write_protect workbook, writer
+    write_placeholder writer, 0x0012
+  end
+  def write_refreshall workbook, writer
+    write_placeholder writer, 0x01b7
+  end
+  def write_sst workbook, writer, offset
+    # Offset  Size  Contents
+    #      0     4  Total number of strings in the workbook (see below)
+    #      4     4  Number of following strings (nm)
+    #      8  var.  List of nm Unicode strings, 16-bit string length (➜ 3.4)
+    num_total = 0
+    strings = worksheets(workbook).inject(Hash.new(0)) do |memo, worksheet|
+      worksheet.strings.each do |k,v|
+        memo[k] += v
+        num_total += v
+      end
+      memo
+    end
+    _write_sst workbook, writer, offset, num_total, strings.keys
+  end
+  def _write_sst workbook, writer, offset, total, strings
+    sst = {}
+    worksheets(workbook).each do |worksheet|
+      offset += worksheet.boundsheet_size
+      @sst[worksheet] = sst
+    end
+    sst_size = strings.size
+    data = [total, sst_size].pack 'V2'
+    op = 0x00fc
+    wide = 0
+    offsets = []
+    strings.each_with_index do |string, idx|
+      sst.store string, idx
+      op_offset = data.size + 4
+      if idx % SST_CHUNKSIZE == 0
+        offsets.push [offset + writer.pos + op_offset, op_offset]
+      end
+      header, packed, next_wide = _unicode_string string, 2
+      # the first few bytes (header + first character) must not be split
+      must_fit = header.size + wide + 1
+      while data.size + must_fit > @recordsize_limit
+        op, data, wide = write_string_part writer, op, data, wide
+      end
+      wide = next_wide
+      data << header << packed
+    end
+    until data.empty?
+      op, data, wide = write_string_part writer, op, data, wide
+    end
+    write_extsst workbook, offsets, writer
+  end
+  def write_sst_changes workbook, writer, offset, total, strings
+    _write_sst workbook, writer, offset, total, strings
+  end
+  def write_string_part writer, op, data, wide
+    bef = data.size
+    ## if we're writing wide characters, we need to make sure we don't cut
+    #  characters in half
+    if wide > 0 && data.size > @recordsize_limit
+      remove = @recordsize_limit - bef
+      remove -= remove % 2
+      rest = data.slice!(remove..-1)
+      write_op writer, op, data
+      data = rest
+    else
+      data = write_op writer, op, data
+    end
+    op = 0x003c
+    # Unicode strings are split in a special way. At the beginning of each
+    # CONTINUE record the option flags byte is repeated. Only the
+    # character size flag will be set in this flags byte, the Rich-Text
+    # flag and the Far-East flag are set to zero.
+    unless data.empty?
+      if wide == 1
+        # check if we can compress the rest of the string
+        data, wide = compress_unicode_string data
+      end
+      data = [wide].pack('C') << data
+    end
+    [op, data, wide]
+  end
+  def write_styles workbook, writer
+    # TODO: Style implementation. The following is simply a standard builtin
+    #       style.
+    # TODO: User defined styles
+    data = [
+      0x8000, #   Bit  Mask    Contents
+              # 11- 0  0x0fff  Index to style XF record (➜ 6.115)
+              #    15  0x8000  Always 1 for built-in styles
+      0x00,   # Identifier of the built-in cell style:
+              # 0x00 = Normal
+              # 0x01 = RowLevel_lv (see next field)
+              # 0x02 = ColLevel_lv (see next field)
+              # 0x03 = Comma
+              # 0x04 = Currency
+              # 0x05 = Percent
+              # 0x06 = Comma [0] (BIFF4-BIFF8)
+              # 0x07 = Currency [0] (BIFF4-BIFF8)
+              # 0x08 = Hyperlink (BIFF8)
+              # 0x09 = Followed Hyperlink (BIFF8)
+      0xff,   # Level for RowLevel or ColLevel style (zero-based, lv),
+              # 0xff otherwise
+              # The RowLevel and ColLevel styles specify the formatting of
+              # subtotal cells in a specific outline level. The level is
+              # specified by the last field in the STYLE record. Valid values
+              # are 0…6 for the outline levels 1…7.
+    ]
+    write_op writer, 0x0293, data.pack('vC2')
+  end
+  def write_palette workbook, writer
+    data = default_palette
+
+    workbook.palette.each do |idx, color|
+      idx = SEDOC_ROLOC[idx] - 8 if idx.kind_of? Symbol
+      raise "Undefined color index: #{idx}" unless data[idx]
+      data[idx] = color
+    end
+
+    writer.write [opcode(:palette), 2 + 4 * data.size, data.size].pack('v3')
+    writer.write data.collect { |c| c.push(0).pack('C4') }.join
+  end
+  def write_tabid workbook, writer
+    write_op writer, 0x013d, [1].pack('v')
+  end
+  def write_window1 workbook, writer
+    selected = workbook.worksheets.find do |sheet| sheet.selected end
+    actidx = workbook.worksheets.index selected
+    data = [
+      0x0000, # Horizontal position of the document window
+              # (in twips = 1/20 of a point)
+      0x0000, # Vertical position of the document window
+              # (in twips = 1/20 of a point)
+      0x4000, # Width of the document window (in twips = 1/20 of a point)
+      0x2000, # Height of the document window (in twips = 1/20 of a point)
+      0x0038, # Option flags:
+              # Bit  Mask    Contents
+              #   0  0x0001  0 = Window is visible
+              #              1 = Window is hidden
+              #   1  0x0002  0 = Window is open
+              #              1 = Window is minimised
+              #   3  0x0008  0 = Horizontal scroll bar hidden
+              #              1 = Horizontal scroll bar visible
+              #   4  0x0010  0 = Vertical scroll bar hidden
+              #              1 = Vertical scroll bar visible
+              #   5  0x0020  0 = Worksheet tab bar hidden
+              #              1 = Worksheet tab bar visible
+      actidx, # Index to active (displayed) worksheet
+      0x0000, # Index of first visible tab in the worksheet tab bar
+      0x0001, # Number of selected worksheets
+              # (highlighted in the worksheet tab bar)
+      0x00e5, # Width of worksheet tab bar (in 1/1000 of window width).
+              # The remaining space is used by the horizontal scrollbar.
+    ]
+    write_op writer, 0x003d, data.pack('v*')
+  end
+  ##
+  # The main writer method. Calls #write_from_scratch or #write_changes
+  # depending on the class and state of _workbook_.
+  def write_workbook workbook, io
+    unless workbook.is_a?(Excel::Workbook) && workbook.io
+      @date_base = Date.new 1899, 12, 31
+      write_from_scratch workbook, io
+    else
+      @date_base = workbook.date_base
+      if workbook.changes.empty?
+        super
+      else
+        write_changes workbook, io
+      end
+    end
+  ensure
+    cleanup workbook
+  end
+  def write_xfs workbook, writer
+    # The default cell format is always present in an Excel file, described by
+    # the XF record with the fixed index 15 (0-based). By default, it uses the
+    # worksheet/workbook default cell style, described by the very first XF
+    # record (index 0).
+    @formats[workbook][:writers].each do |fmt| fmt.write_xf writer end
+  end
+  def sst_index worksheet, str
+    @sst[worksheet][str]
+  end
+  def xf_index workbook, format
+    @formats[workbook][:xf_indexes][format] || 0
+  end
+  ##
+  # Returns Excel 97+ default colour palette.
+  def default_palette
+    [
+      [0x00, 0x00, 0x00],
+      [0xff, 0xff, 0xff],
+      [0xff, 0x00, 0x00],
+      [0x00, 0xff, 0x00],
+      [0x00, 0x00, 0xff],
+      [0xff, 0xff, 0x00],
+      [0xff, 0x00, 0xff],
+      [0x00, 0xff, 0xff],
+      [0x80, 0x00, 0x00],
+      [0x00, 0x80, 0x00],
+      [0x00, 0x00, 0x80],
+      [0x80, 0x80, 0x00],
+      [0x80, 0x00, 0x80],
+      [0x00, 0x80, 0x80],
+      [0xc0, 0xc0, 0xc0],
+      [0x80, 0x80, 0x80],
+      [0x99, 0x99, 0xff],
+      [0x99, 0x33, 0x66],
+      [0xff, 0xff, 0xcc],
+      [0xcc, 0xff, 0xff],
+      [0x66, 0x00, 0x66],
+      [0xff, 0x80, 0x80],
+      [0x00, 0x66, 0xcc],
+      [0xcc, 0xcc, 0xff],
+      [0x00, 0x00, 0x80],
+      [0xff, 0x00, 0xff],
+      [0xff, 0xff, 0x00],
+      [0x00, 0xff, 0xff],
+      [0x80, 0x00, 0x80],
+      [0x80, 0x00, 0x00],
+      [0x00, 0x80, 0x80],
+      [0x00, 0x00, 0xff],
+      [0x00, 0xcc, 0xff],
+      [0xcc, 0xff, 0xff],
+      [0xcc, 0xff, 0xcc],
+      [0xff, 0xff, 0x99],
+      [0x99, 0xcc, 0xff],
+      [0xff, 0x99, 0xcc],
+      [0xcc, 0x99, 0xff],
+      [0xff, 0xcc, 0x99],
+      [0x33, 0x66, 0xff],
+      [0x33, 0xcc, 0xcc],
+      [0x99, 0xcc, 0x00],
+      [0xff, 0xcc, 0x00],
+      [0xff, 0x99, 0x00],
+      [0xff, 0x66, 0x00],
+      [0x66, 0x66, 0x99],
+      [0x96, 0x96, 0x96],
+      [0x00, 0x33, 0x66],
+      [0x33, 0x99, 0x66],
+      [0x00, 0x33, 0x00],
+      [0x33, 0x33, 0x00],
+      [0x99, 0x33, 0x00],
+      [0x99, 0x33, 0x66],
+      [0x33, 0x33, 0x99],
+      [0x33, 0x33, 0x33]
+    ]
+  end
+end
+    end
+  end
+end