slayer-surpass 0.1.0

data/lib/surpass/biff_record.rb

@@ -0,0 +1,2173 @@
+class SharedStringTable
+  SST_ID = 0x00FC
+  
+  def initialize
+    @sst_record = nil
+    @continues = []
+    @current_piece = [0,0].pack('V2')
+
+    @str_indexes = {} # TODO replace with array? or is hash more efficient?
+    @add_calls = 0
+  end
+  
+  def add_str(s)
+    @add_calls += 1
+    index = @str_indexes[s]
+    if index.nil?
+      # This is a new string for the SST.
+      position = @str_indexes.length
+      @str_indexes[s] = position
+      index = position
+      add_to_sst(s)
+    end
+    index
+  end
+  
+  def str_index(s)
+    @str_indexes[s]
+  end
+  
+  def to_biff
+    new_piece # flush the 'current' piece
+    result = [SST_ID, @sst_record.length, @add_calls, @str_indexes.length].pack('v2V2')
+    result += @sst_record[8..-1]
+    result += @continues.join
+    result
+  end
+  
+  def add_to_sst(s)
+    u_str = mock_unicode_string(s)
+    raise "very long string" if u_str.length > 0xFFFF
+    save_atom(u_str[0...4])
+    save_splitted(u_str[4..-1], false)
+  end
+  
+  # Store the @current_piece in @continues and initialize a new @current_piece
+  def new_piece
+    if @sst_record.nil?
+      # We get here when we first run out of space, or if that never happens then we end
+      # up here when everything is finished and we call to_biff for the first time.
+      @sst_record = @current_piece
+    else
+      @continues << [BiffRecord::CONTINUE_RECORD_ID, @current_piece.length].pack('v2') + @current_piece
+    end
+    @current_piece = ''
+  end
+  
+  def save_atom(atom)
+    free_space = 0x2020 - @current_piece.length
+    new_piece if free_space < atom.length
+    @current_piece += atom
+  end
+  
+  def save_splitted(s, is_unicode_str)
+    i = 0
+    while i < s.length do
+      free_space = 0x2020 - @current_piece.length
+      tail_length = s.length - i
+      need_more_space = free_space < tail_length
+      
+      if !need_more_space
+        atom_length = tail_length
+      else
+        if is_unicode_str
+          atom_length = free_space & 0xFFFE
+        else
+          atom_length = free_space
+        end
+      end
+      @current_piece += s[i...(i+atom_length)]
+      
+      if need_more_space
+        new_piece
+        if is_unicode_str
+          @current_piece += "\001"
+        else
+          @current_piece += "\000"
+        end
+      end
+      
+      i += atom_length
+    end
+  end
+end
+
+class BiffRecord
+  attr_accessor :record_data
+  
+  BIFF_LIMIT = 0x2020 # limit for BIFF7/8
+  CONTINUE_RECORD_ID = 0x003C
+
+  # By default, initialize to ''.
+  # May be overridden in subclass.
+  def initialize
+    @record_data = ''
+  end
+  
+### @export "biff-record"
+  def record_header
+    [self.class::RECORD_ID, @record_data.length].pack('v2')
+  end
+
+  def to_biff
+    if @record_data.length > BIFF_LIMIT
+      chunks = []
+      pos = 0
+      while pos < @record_data.length
+        chunk_pos = pos + BIFF_LIMIT
+        chunk = @record_data[pos...chunk_pos]
+        chunks << chunk
+        pos = chunk_pos
+      end
+      
+      continues = [self.class::RECORD_ID, chunks[0].length].pack('v2') + chunks[0]
+      chunks.each_with_index do |c, i|
+        next if i == 0
+        continues += [CONTINUE_RECORD_ID, c.length].pack('v2') + c
+      end
+      continues
+    else
+      record_header + @record_data
+    end
+  end
+### @end
+end
+
+# Offset Size Contents
+# 0      2    Version, contains 0600H for BIFF8 and BIFF8X
+# 2      2    Type of the following data:
+#               0005H = Workbook globals
+#               0006H = Visual Basic module
+#               0010H = Worksheet
+#               0020H = Chart
+#               0040H = Macro sheet
+#               0100H = Workspace file
+# 4      2    Build identifier
+# 6      2    Build year
+# 8      4    File history flags
+# 12     4    Lowest Excel version that can read all records in this file
+### @export "biffbof-record"
+class Biff8BOFRecord < BiffRecord
+  RECORD_ID = 0x0809
+  
+  # Stream Types
+  BOOK_GLOBAL = 0x0005
+  VB_MODULE   = 0x0006
+  WORKSHEET   = 0x0010
+  CHART       = 0x0020
+  MACROSHEET  = 0x0040
+  WORKSPACE   = 0x0100
+  
+  def initialize(rec_type)
+    version  = 0x0600
+    build    = 0x0DBB
+    year     = 0x07CC
+    file_hist_flags = 0x00
+    ver_can_read    = 0x06
+    
+    @record_data = [version, rec_type, build, year, file_hist_flags, ver_can_read].pack('v4V2')
+  end
+end
+### @end
+
+class InterfaceHeaderRecord < BiffRecord
+  RECORD_ID = 0x00E1
+  
+  def initialize
+    @record_data = [0xB0, 0x04].pack('C2')
+  end
+end
+
+class InterfaceEndRecord < BiffRecord
+  RECORD_ID = 0x00E2
+end
+
+class MMSRecord < BiffRecord
+  RECORD_ID = 0x00C1
+  def initialize
+    @record_data = [0x00].pack('v')
+  end
+end
+
+# This record is part of the file protection. It contains the name of the
+# user  that  has  saved  the  file. The user name is always stored as an
+# equal-sized  string.  All  unused  characters after the name are filled
+# with space characters. It is not required to write the mentioned string
+# length. Every other length will be accepted too.
+class WriteAccessRecord < BiffRecord
+  RECORD_ID = 0x005C
+  
+  # TODO Can we extend this to 0x70? I think 0x30 is a holdover from Biff7 but 112 chars is Biff8.
+  def initialize(owner)
+    @record_data = [owner[0, 0x30]].pack('A112')
+  end
+end
+
+# This  record  specifies  if the file contains an additional BIFF5/BIFF7
+# workbook stream.
+# Record DSF, BIFF8:
+# Offset Size Contents
+# 0        2     0 = Only the BIFF8 Workbook stream is present
+#                1 = Additional BIFF5/BIFF7 Book stream is in the file
+# A  double  stream file can be read by Excel 5.0 and Excel 95, and still
+# contains  all  new  features  added to BIFF8 (which are left out in the
+# BIFF5/BIFF7 Book stream).
+class DSFRecord < BiffRecord
+  RECORD_ID = 0x0161
+  
+  def initialize
+    @record_data = [0x00].pack('v')
+  end
+end
+
+class TabIDRecord < BiffRecord
+  RECORD_ID = 0x013D
+  
+  def initialize(sheetcount)
+    @record_data = ''
+    for i in 1..sheetcount do
+      @record_data += [i].pack('v')
+    end
+  end
+end
+
+class FnGroupCountRecord < BiffRecord
+  RECORD_ID = 0x009C
+  
+  def initialize
+    @record_data = [0x0E, 0X00].pack('C2')
+  end
+end
+
+# This record is part of the worksheet/workbook protection. It determines
+# whether  the window configuration of this document is protected. Window
+# protection is not active, if this record is omitted.
+class WindowProtectRecord < BiffRecord
+  RECORD_ID = 0x0019
+  
+  def initialize(protect)
+    @record_data = [protect].pack('v')
+  end
+end
+
+# This record is part of the worksheet/workbook protection.
+# It determines whether the objects of the current sheet are protected.
+# Object protection is not active, if this record is omitted.
+class ObjectProtectRecord < BiffRecord
+  RECORD_ID = 0x0063
+  
+  def initialize(protect)
+    @record_data = [protect].pack('v')
+  end
+end
+
+# This record is part of the worksheet/workbook protection. It
+# determines whether the scenarios of the current sheet are protected.
+# Scenario protection is not active, if this record is omitted.
+class ScenarioProtectRecord < BiffRecord
+  RECORD_ID = 0x00DD
+  
+  def initialize(protect)
+    @record_data = [protect].pack('v')
+  end
+end
+
+# This record is part of the worksheet/workbook protection. It
+# determines whether the scenarios of the current sheet are protected.
+# Scenario protection is not active, if this record is omitted.
+class ProtectRecord < BiffRecord
+  RECORD_ID = 0x0012
+  
+  def initialize(protect)
+    @record_data = [protect].pack('v')
+  end
+end
+
+# This record is part of the worksheet/workbook protection. It
+# stores a 16-bit hash value, calculated from the worksheet or workbook
+# protection password.
+class PasswordRecord < BiffRecord
+  RECORD_ID = 0x0013
+  
+  def initialize(password = "")
+    @record_data = [password_hash(password)].pack('v')
+  end
+  
+  # Based on the algorithm provided by Daniel Rentz of OpenOffice.
+  def password_hash(plaintext)
+    return 0 if plaintext === ""
+    hash = 0x0000
+    plaintext.unpack('C*').each_with_index do |t, i|
+      c = t << (i + 1)
+      low_15 = c & 0x7fff
+      high_15 = c & 0x7fff << 15
+      high_15 = high_15 >> 15
+      c = low_15 | high_15
+      hash = (hash ^ c)
+    end
+    hash = (hash ^ plaintext.length)
+    hash = (hash ^ 0xCE4B)
+    hash
+  end
+end
+
+class Prot4RevRecord < BiffRecord
+  RECORD_ID = 0x01AF
+  
+  def initialize
+    @record_data = [0x00].pack('v')
+  end
+end
+
+class Prot4RevPassRecord < BiffRecord
+  RECORD_ID = 0x01BC
+  
+  def initialize
+    @record_data = [0x00].pack('v')
+  end
+end
+
+# This  record  contains  a Boolean value determining whether Excel makes
+# a backup of the file while saving.
+class BackupRecord < BiffRecord
+  RECORD_ID = 0x0040
+  
+  def initialize(backup)
+    @record_data = [backup].pack('v')
+  end
+end
+
+# This record specifies whether and how to show objects in the workbook.
+# 
+# Record HIDEOBJ, BIFF3-BIFF8:
+# Offset  Size    Contents
+# 0       2       Viewing mode for objects:
+#                     0 = Show all objects
+#                     1 = Show placeholders
+#                     2 = Do not show objects
+class HideObjRecord < BiffRecord
+  RECORD_ID = 0x008D
+  
+  def initialize
+    @record_data = [0x00].pack('v')
+  end
+end
+
+class RefreshAllRecord < BiffRecord
+  RECORD_ID = 0x01B7
+  
+  def initialize
+    @record_data = [0x00].pack('v')
+  end
+end
+
+# This record contains a Boolean value determining whether to save values
+# linked  from external workbooks (CRN records and XCT records). In BIFF3
+# and BIFF4 this option is stored in the WSBOOL record.
+# 
+# Record BOOKBOOL, BIFF5-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       0 = Save external linked values;
+#                 1 = Do not save external linked values
+class BookBoolRecord < BiffRecord
+  RECORD_ID = 0x00DA
+  
+  def initialize
+    @record_data = [0x00].pack('v')
+  end
+end
+
+# This   record   stores  two  Windows  country  identifiers.  The  first
+# represents  the  user  interface language of the Excel version that has
+# saved  the file, and the second represents the system regional settings
+# at the time the file was saved.
+# 
+# Record COUNTRY, BIFF3-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Windows country identifier of the user interface language of Excel
+# 2       2       Windows country identifier of the system regional settings
+# 
+# The  following  table  shows most of the used country identifiers. Most
+# of  these  identifiers  are  equal to the international country calling
+# codes.
+# 
+# 1   USA
+# 2   Canada
+# 7   Russia
+class CountryRecord < BiffRecord
+  RECORD_ID = 0x00DA
+  
+  def initialize(ui_id, sys_settings_id)
+    @record_data = [ui_id, sys_settings_id].pack('v2')
+  end
+end
+
+# This  record  specifies if the formulas in the workbook can use natural
+# language  formulasî.  This  type  of  formula can refer to cells by its
+# content or the content of the column or row header cell.
+# 
+# Record USESELFS, BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       0 = Do not use natural language formulas
+#                 1 = Use natural language formulas
+class UseSelfsRecord < BiffRecord
+  RECORD_ID = 0x0160
+  
+  def initialize
+    @record_data = [0x01].pack('v')
+  end
+end
+
+class EOFRecord < BiffRecord
+  RECORD_ID = 0x000A
+end
+
+# This  record  specifies  the  base date for displaying date values. All
+# dates  are  stored as count of days past this base date. In BIFF2-BIFF4
+# this   record  is  part  of  the  Calculation  Settings  Block.
+# In BIFF5-BIFF8 it is stored in the Workbook Globals Substream.
+# 
+# Record DATEMODE, BIFF2-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       0 = Base is 1899-Dec-31 (the cell = 1 represents 1900-Jan-01)
+#                 1 = Base is 1904-Jan-01 (the cell = 1 represents 1904-Jan-02)
+class DateModeRecord < BiffRecord
+  RECORD_ID = 0x0022
+  
+  def initialize(boolean)
+    @record_data = boolean ? [1].pack('v') : [0].pack('v')
+  end
+end
+
+# This record stores if formulas use the real cell values for calculation
+# or  the  values  displayed  on  the screen. In BIFF2- BIFF4 this record
+# is  part of the Calculation Settings Block. In BIFF5-BIFF8 it is stored
+# in the Workbook Globals Substream.
+# 
+# Record PRECISION, BIFF2-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       0 = Use displayed values;
+#                 1 = Use real cell values
+class PrecisionRecord < BiffRecord
+  RECORD_ID = 0x000E
+  
+  def initialize(boolean)
+    @record_data = boolean ? [1].pack('v') : [0].pack('v')
+  end
+end
+
+# This record stores the text encoding used to write byte strings, stored
+# as MS Windows code page identifier. The CODEPAGE record in BIFF8 always
+# contains  the  code  page  1200  (UTF-16).  Therefore  it is not
+# possible  to  obtain the encoding used for a protection password (it is
+# not UTF-16).
+# 
+# Record CODEPAGE, BIFF2-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Code page identifier used for byte string text encoding:
+#                   016FH = 367 = ASCII
+#                   01B5H = 437 = IBM PC CP-437 (US)
+#                   02D0H = 720 = IBM PC CP-720 (OEM Arabic)
+#                   02E1H = 737 = IBM PC CP-737 (Greek)
+#                   0307H = 775 = IBM PC CP-775 (Baltic)
+#                   0352H = 850 = IBM PC CP-850 (Latin I)
+#                   0354H = 852 = IBM PC CP-852 (Latin II (Central European))
+#                   0357H = 855 = IBM PC CP-855 (Cyrillic)
+#                   0359H = 857 = IBM PC CP-857 (Turkish)
+#                   035AH = 858 = IBM PC CP-858 (Multilingual Latin I with Euro)
+#                   035CH = 860 = IBM PC CP-860 (Portuguese)
+#                   035DH = 861 = IBM PC CP-861 (Icelandic)
+#                   035EH = 862 = IBM PC CP-862 (Hebrew)
+#                   035FH = 863 = IBM PC CP-863 (Canadian (French))
+#                   0360H = 864 = IBM PC CP-864 (Arabic)
+#                   0361H = 865 = IBM PC CP-865 (Nordic)
+#                   0362H = 866 = IBM PC CP-866 (Cyrillic (Russian))
+#                   0365H = 869 = IBM PC CP-869 (Greek (Modern))
+#                   036AH = 874 = Windows CP-874 (Thai)
+#                   03A4H = 932 = Windows CP-932 (Japanese Shift-JIS)
+#                   03A8H = 936 = Windows CP-936 (Chinese Simplified GBK)
+#                   03B5H = 949 = Windows CP-949 (Korean (Wansung))
+#                   03B6H = 950 = Windows CP-950 (Chinese Traditional BIG5)
+#                   04B0H = 1200 = UTF-16 (BIFF8)
+#                   04E2H = 1250 = Windows CP-1250 (Latin II) (Central European)
+#                   04E3H = 1251 = Windows CP-1251 (Cyrillic)
+#                   04E4H = 1252 = Windows CP-1252 (Latin I) (BIFF4-BIFF7)
+#                   04E5H = 1253 = Windows CP-1253 (Greek)
+#                   04E6H = 1254 = Windows CP-1254 (Turkish)
+#                   04E7H = 1255 = Windows CP-1255 (Hebrew)
+#                   04E8H = 1256 = Windows CP-1256 (Arabic)
+#                   04E9H = 1257 = Windows CP-1257 (Baltic)
+#                   04EAH = 1258 = Windows CP-1258 (Vietnamese)
+#                   0551H = 1361 = Windows CP-1361 (Korean (Johab))
+#                   2710H = 10000 = Apple Roman
+#                   8000H = 32768 = Apple Roman
+#                   8001H = 32769 = Windows CP-1252 (Latin I) (BIFF2-BIFF3)
+class CodepageBiff8Record < BiffRecord
+  RECORD_ID = 0x0042
+  UTF_16 = 0x04B0
+  
+  def initialize
+    @record_data = [UTF_16].pack('v')
+  end
+end
+
+# Offset Size Contents
+# 0      2    Horizontal position of the document window (in twips = 1/20 of a point)
+# 2      2    Vertical position of the document window (in twips = 1/20 of a point)
+# 4      2    Width of the document window (in twips = 1/20 of a point)
+# 6      2    Height of the document window (in twips = 1/20 of a point)
+# 8      2    Option flags:
+#               Bits  Mask  Contents
+#               0     0001H 0 = Window is visible 1 = Window is hidden
+#               1     0002H 0 = Window is open 1 = Window is minimised
+#               3     0008H 0 = Horizontal scroll bar hidden 1 = Horizontal scroll bar visible
+#               4     0010H 0 = Vertical scroll bar hidden 1 = Vertical scroll bar visible
+#               5     0020H 0 = Worksheet tab bar hidden 1 = Worksheet tab bar visible
+# 10     2    Index to active (displayed) worksheet
+# 12     2    Index of first visible tab in the worksheet tab bar
+# 14     2    Number of selected worksheets (highlighted in the worksheet tab bar)
+# 16     2    Width of worksheet tab bar (in 1/1000 of window width). The remaining space is used by the
+#             horizontal scrollbar.
+class Window1Record < BiffRecord
+  RECORD_ID = 0x003D
+  
+  def initialize(hpos_twips, vpos_twips, width_twips, height_twips, flags, active_sheet, first_tab_index, selected_tabs, tab_width)
+    args = [hpos_twips, vpos_twips, width_twips, height_twips, flags, active_sheet, first_tab_index, selected_tabs, tab_width]
+    @record_data = args.pack('v9')
+  end
+end
+
+# WARNING
+#     The font with index 4 is omitted in all BIFF versions.
+#     This means the first four fonts have zero-based indexes, and
+#     the fifth font and all following fonts are referenced with one-based
+#     indexes.
+# 
+# Offset Size Contents
+# 0      2    Height of the font (in twips = 1/20 of a point)
+# 2      2    Option flags:
+#               Bit Mask    Contents
+#               0   0001H   1 = Characters are bold (redundant, see below)
+#               1   0002H   1 = Characters are italic
+#               2   0004H   1 = Characters are underlined (redundant, see below)
+#               3   0008H   1 = Characters are struck out
+#                     0010H 1 = Outline
+#                     0020H  1 = Shadow
+# 4     2     Colour index
+# 6     2     Font weight (100-1000).
+#             Standard values are 0190H (400) for normal text and 02BCH
+#             (700) for bold text.
+# 8     2     Escapement type:
+#               0000H = None
+#               0001H = Superscript
+#               0002H = Subscript
+# 10    1     Underline type:
+#               00H = None
+#               01H = Single
+#               21H = Single accounting
+#               02H = Double
+#               22H = Double accounting
+# 11    1     Font family:
+#               00H = None (unknown or don't care)
+#               01H = Roman (variable width, serifed)
+#               02H = Swiss (variable width, sans-serifed)
+#               03H = Modern (fixed width, serifed or sans-serifed)
+#               04H = Script (cursive)
+#               05H = Decorative (specialised, i.e. Old English, Fraktur)
+# 12    1     Character set:
+#               00H = 0 = ANSI Latin
+#               01H = 1 = System default
+#               02H = 2 = Symbol
+#               4DH = 77 = Apple Roman
+#               80H = 128 = ANSI Japanese Shift-JIS
+#               81H = 129 = ANSI Korean (Hangul)
+#               82H = 130 = ANSI Korean (Johab)
+#               86H = 134 = ANSI Chinese Simplified GBK
+#               88H = 136 = ANSI Chinese Traditional BIG5
+#               A1H = 161 = ANSI Greek
+#               A2H = 162 = ANSI Turkish
+#               A3H = 163 = ANSI Vietnamese
+#               B1H = 177 = ANSI Hebrew
+#               B2H = 178 = ANSI Arabic
+#               BAH = 186 = ANSI Baltic
+#               CCH = 204 = ANSI Cyrillic
+#               DEH = 222 = ANSI Thai
+#               EEH = 238 = ANSI Latin II (Central European)
+#               FFH = 255 = OEM Latin I
+# 13    1     Not used
+# 14    var.  Font name:
+#               BIFF5/BIFF7: Byte string, 8-bit string length
+#               BIFF8: Unicode string, 8-bit string length
+# The boldness and underline flags are still set in the options field,
+# but not used on reading the font. Font weight and underline type
+# are specified in separate fields instead.
+class FontRecord < BiffRecord
+  RECORD_ID = 0x0031
+  
+  def initialize(height, options, colour_index, weight, escapement, underline, family, charset, name)
+    #TODO implement upack1 fully
+    args = [height, options, colour_index, weight, escapement,underline, family, charset, 0x00]
+    @record_data = args.pack('v5C4') + [name.length, 0].pack('CC') + name
+  end
+end
+
+# Record FORMAT, BIFF8:
+# Offset  Size    Contents
+# 0       2       Format index used in other records
+# 2       var.    Number format string (Unicode string, 16-bit string length)
+# 
+# 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.  The following table 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.
+# 
+# The built-in number formats, BIFF5-BIFF8
+# 
+# Index   Type        Format string
+# 0       General     General
+# 1       Decimal     0
+# 2       Decimal     0.00
+# 3       Decimal     #,##0
+# 4       Decimal     #,##0.00
+# 5       Currency    "$"#,##0_);("$"#,##
+# 6       Currency    "$"#,##0_);[Red]("$"#,##
+# 7       Currency    "$"#,##0.00_);("$"#,##
+# 8       Currency    "$"#,##0.00_);[Red]("$"#,##
+# 9       Percent     0%
+# 10      Percent     0.00%
+# 11      Scientific  0.00E+00
+# 12      Fraction    # ?/?
+# 13      Fraction    # ??/??
+# 14      Date        M/D/YY
+# 15      Date        D-MMM-YY
+# 16      Date        D-MMM
+# 17      Date        MMM-YY
+# 18      Time        h:mm AM/PM
+# 19      Time        h:mm:ss AM/PM
+# 20      Time        h:mm
+# 21      Time        h:mm:ss
+# 22      Date/Time   M/D/YY h:mm
+# 37      Account     _(#,##0_);(#,##0)
+# 38      Account     _(#,##0_);[Red](#,##0)
+# 39      Account     _(#,##0.00_);(#,##0.00)
+# 40      Account     _(#,##0.00_);[Red](#,##0.00)
+# 41      Currency    _("$"* #,##0_);_("$"* (#,##0);_("$"* "-"_);_(@_)
+# 42      Currency    _(* #,##0_);_(* (#,##0);_(* "-"_);_(@_)
+# 43      Currency    _("$"* #,##0.00_);_("$"* (#,##0.00);_("$"* "-"??_);_(@_)
+# 44      Currency    _(* #,##0.00_);_(* (#,##0.00);_(* "-"??_);_(@_)
+# 45      Time        mm:ss
+# 46      Time        [h]:mm:ss
+# 47      Time        mm:ss.0
+# 48      Scientific  ##0.0E+0
+# 49      Text        @
+class NumberFormatRecord < BiffRecord
+  RECORD_ID = 0x041E
+  
+  def initialize(index, format_string)
+    @record_data = [index].pack('v') + mock_unicode_string(format_string)
+  end
+end
+
+#  XF Substructures
+#  -------------------------------------------------------------------------
+#  XF_TYPE_PROT  XF Type and Cell Protection (3 Bits), BIFF3-BIFF8
+#  These 3 bits are part of a specific data byte.
+#  Bit Mask    Contents
+#  0   01H     1 = Cell is locked
+#  1   02H     1 = Formula is hidden
+#  2   04H     0 = Cell XF; 1 = Style XF
+# 
+#  XF_USED_ATTRIB   Attributes   Used  from  Parent  Style  XF  (6  Bits),
+#  BIFF3-BIFF8  Each  bit  describes  the  validity  of  a  specific group
+#  of  attributes.  In  cell XFs a cleared bit means the attributes of the
+#  parent  style XF are used (but only if the attributes are valid there),
+#  a  set  bit  means  the  attributes  of  this XF are used. In style XFs
+#  a cleared bit means the attribute setting is valid, a set bit means the
+#  attribute should be ignored.
+#  Bit Mask    Contents
+#  0   01H     Flag for number format
+#  1   02H     Flag for font
+#  2   04H     Flag for horizontal and vertical alignment, text wrap, indentation, orientation, rotation, and
+#              text direction
+#  3   08H     Flag for border lines
+#  4   10H     Flag for background area style
+#  5   20H     Flag for cell protection (cell locked and formula hidden)
+# 
+#  XF_HOR_ALIGN  Horizontal Alignment (3 Bits), BIFF2-BIFF8 The horizontal
+#  alignment consists of 3 bits and is part of a specific data byte.
+#  Value   Horizontal alignment
+#  00H     General
+#  01H     Left
+#  02H     Centred
+#  03H     Right
+#  04H     Filled
+#  05H     Justified (BIFF4-BIFF8X)
+#  06H     Centred across selection (BIFF4-BIFF8X)
+#  07H     Distributed (BIFF8X)
+# 
+#  XF_VERT_ALIGN Vertical Alignment (2 or 3 Bits), BIFF4-BIFF8
+#  The vertical alignment consists of 2 bits (BIFF4) or 3 bits (BIFF5-BIFF8)
+#  and is part of a specific data byte. Vertical alignment is not available
+#  in BIFF2 and BIFF3.
+#  Value   Vertical alignment
+#  00H     Top
+#  01H     Centred
+#  02H     Bottom
+#  03H     Justified (BIFF5-BIFF8X)
+#  04H     Distributed (BIFF8X)
+# 
+#  XF_ORIENTATION  Text  Orientation  (2  Bits),  BIFF4-BIFF7  In the BIFF
+#  versions  BIFF4-BIFF7,  text  can  be  rotated  in  steps of 90 degrees
+#  or  stacked.  The  orientation  mode  consists of 2 bits and is part of
+#  a specific data byte. In BIFF8 a rotation angle occurs instead of these
+#  flags.
+#  Value   Text orientation
+#  00H     Not rotated
+#  01H     Letters are stacked top-to-bottom, but not rotated
+#  02H     Text is rotated 90 degrees counterclockwise
+#  03H     Text is rotated 90 degrees clockwise
+# 
+#  XF_ROTATION Text Rotation Angle (1 Byte), BIFF8
+#  Value   Text rotation
+#  0       Not rotated
+#  1-90    1 to 90 degrees counterclockwise
+#  91-180  1 to 90 degrees clockwise
+#  255     Letters are stacked top-to-bottom, but not rotated
+# 
+#  XF_BORDER_34  Cell  Border  Style  (4  Bytes), BIFF3-BIFF4 Cell borders
+#  contain a line style and a line colour for each line of the border.
+#  Bit     Mask        Contents
+#  2-0     00000007H   Top line style
+#  7-3     000000F8H   Colour index for top line colour
+#  10-8    00000700H   Left line style
+#  15-11   0000F800H   Colour index for left line colour
+#  18-16   00070000H   Bottom line style
+#  23-19   00F80000H   Colour index for bottom line colour
+#  26-24   07000000H   Right line style
+#  31-27   F8000000H   Colour index for right line colour
+# 
+#  XF_AREA_34  Cell  Background  Area  Style (2 Bytes), BIFF3-BIFF4 A cell
+#  background  area  style  contains  an area pattern and a foreground and
+#  background colour.
+#  Bit     Mask    Contents
+#  5-0     003FH   Fill pattern
+#  10-6    07C0H   Colour index for pattern colour
+#  15-11   F800H   Colour index for pattern background
+# ---------------------------------------------------------------------------------------------
+#  Record XF, BIFF8:
+#  Offset      Size    Contents
+#  0           2       Index to FONT record
+#  2           2       Index to FORMAT record
+#  4           2       Bit     Mask    Contents
+#                      2-0     0007H   XF_TYPE_PROT . XF type, cell protection (see above)
+#                      15-4    FFF0H   Index to parent style XF (always FFFH in style XFs)
+#  6           1       Bit     Mask    Contents
+#                      2-0     07H     XF_HOR_ALIGN . Horizontal alignment (see above)
+#                      3       08H     1 = Text is wrapped at right border
+#                      6-4     70H     XF_VERT_ALIGN . Vertical alignment (see above)
+#  7           1       XF_ROTATION: Text rotation angle (see above)
+#  8           1       Bit     Mask    Contents
+#                      3-0     0FH     Indent level
+#                      4       10H     1 = Shrink content to fit into cell
+#                      5               merge
+#                      7-6     C0H     Text direction (BIFF8X only)
+#                                      00b = According to context
+#                                      01b = Left-to-right
+#                                      10b = Right-to-left
+#  9           1       Bit     Mask    Contents
+#                      7-2     FCH     XF_USED_ATTRIB . Used attributes (see above)
+#  10          4       Cell border lines and background area:
+#                      Bit     Mask      Contents
+#                      3-0     0000000FH Left line style
+#                      7-4     000000F0H Right line style
+#                      11-8    00000F00H Top line style
+#                      15-12   0000F000H Bottom line style
+#                      22-16   007F0000H Colour index for left line colour
+#                      29-23   3F800000H Colour index for right line colour
+#                      30      40000000H 1 = Diagonal line from top left to right bottom
+#                      31      80000000H 1 = Diagonal line from bottom left to right top
+#  14          4       Bit     Mask      Contents
+#                      6-0     0000007FH Colour index for top line colour
+#                      13-7    00003F80H Colour index for bottom line colour
+#                      20-14   001FC000H Colour index for diagonal line colour
+#                      24-21   01E00000H Diagonal line style
+#                      31-26   FC000000H Fill pattern
+#  18          2       Bit     Mask    Contents
+#                      6-0     007FH   Colour index for pattern colour
+#                      13-7    3F80H   Colour index for pattern background
+class XFRecord < BiffRecord
+  RECORD_ID = 0x00E0
+  
+  def initialize(xf, xf_type = 'cell')
+    font_xf_idx, fmt_str_xf_idx, alignment, borders, pattern, protection = xf
+    
+    fnt = [font_xf_idx].pack('v')
+    fmt = [fmt_str_xf_idx].pack('v')
+    
+    if xf_type === 'cell'
+      protection = ((protection.cell_locked & 0x01) << 0) | ((protection.formula_hidden & 0x01) << 1)
+      prt = [protection].pack('v')
+    else
+      prt = [0xFFF5].pack('v')
+    end
+    
+    aln_value = ((alignment.horz & 0x07) << 0) | ((alignment.wrap & 0x01) << 3) | ((alignment.vert & 0x07) << 4)
+    aln = [aln_value].pack('C')
+    
+    rot = [alignment.rota].pack('C')
+    
+    txt_value = ((alignment.inde & 0x0F) << 0) | ((alignment.shri & 0x01) << 4) | ((alignment.merg & 0x01) << 5) | ((alignment.dire & 0x03) << 6)
+    txt = [txt_value].pack('C')
+    
+    used_attr = (xf_type === 'cell') ? [0xF8].pack('C') : [0xF4].pack('C')
+    
+    borders.left_colour = 0x00 if borders.left == Borders::NO_LINE
+    borders.right_colour = 0x00 if borders.right == Borders::NO_LINE
+    borders.top_colour = 0x00 if borders.top == Borders::NO_LINE
+    borders.bottom_colour = 0x00 if borders.bottom == Borders::NO_LINE
+    borders.diag_colour = 0x00 if borders.diag == Borders::NO_LINE
+    
+    brd1_value = ((borders.left          & 0x0F) << 0 ) |
+    ((borders.right         & 0x0F) << 4 ) |
+    ((borders.top           & 0x0F) << 8 ) |
+    ((borders.bottom        & 0x0F) << 12) |
+    ((borders.left_colour   & 0x7F) << 16) |
+    ((borders.right_colour  & 0x7F) << 23) |
+    ((borders.need_diag1    & 0x01) << 30) |
+    ((borders.need_diag2    & 0x01) << 31)
+    
+    brd1 = [brd1_value].pack('V')
+    
+    brd2_value = ((borders.top_colour    & 0x7F) << 0 ) |
+          ((borders.bottom_colour & 0x7F) << 7 ) |
+          ((borders.diag_colour   & 0x7F) << 14) |
+          ((borders.diag          & 0x0F) << 21) |
+          ((pattern.pattern       & 0x3F) << 26)
+          
+    brd2 = [brd2_value].pack('V')
+    
+    pat_value = ((pattern.pattern_fore_colour & 0x7F) << 0 ) |
+          ((pattern.pattern_back_colour & 0x7F) << 7 )
+    pat = [pat_value].pack('v')
+
+    @record_data = fnt + fmt + prt + aln + rot + txt + used_attr + brd1 + brd2 + pat
+  end
+end
+
+# STYLE record for user-defined cell styles, BIFF3-BIFF8:
+# Offset  Size    Contents
+# 0       2       Bit     Mask    Contents
+#                 11-0    0FFFH   Index to style XF record
+#                 15      8000H   Always 0 for user-defined styles
+# 2       var.    BIFF2-BIFF7: Non-empty byte string, 8-bit string length
+#                 BIFF8: Non-empty Unicode string, 16-bit string length
+# STYLE record for built-in cell styles, BIFF3-BIFF8:
+# Offset  Size    Contents
+# 0       2       Bit     Mask    Contents
+#                 11-0    0FFFH   Index to style XF record
+#                 15      8000H   Always 1 for built-in styles
+# 2       1       Identifier of the built-in cell style:
+#                     00H = Normal
+#                     01H = RowLevel_lv (see next field)
+#                     02H = ColLevel_lv (see next field)
+#                     03H = Comma
+#                     04H = Currency
+#                     05H = Percent
+#                     06H = Comma [0] (BIFF4-BIFF8)
+#                     07H = Currency [0] (BIFF4-BIFF8)
+#                     08H = Hyperlink (BIFF8)
+#                     09H = Followed Hyperlink (BIFF8)
+# 3       1       Level for RowLevel or ColLevel style
+#                 (zero-based, lv), FFH 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.
+class StyleRecord < BiffRecord
+  RECORD_ID = 0x0293
+  
+  def initialize
+    @record_data = [0x8000, 0x00, 0xFF].pack('vCC')
+    # TODO: implement user-defined styles???
+  end
+end
+
+# This  record  contains  the  definition  of  all  user-defined  colours
+# available for cell and object formatting.
+# 
+# Record PALETTE, BIFF3-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Number of following colours (nm). Contains 16 in BIFF3-BIFF4 and 56 in BIFF5-BIFF8.
+# 2       4*nm    List of nm RGB colours
+# 
+# The following table shows how colour indexes are used in other records:
+# 
+# Colour index    Resulting colour or internal list index
+# 00H             Built-in Black (R = 00H, G = 00H, B = 00H)
+# 01H             Built-in White (R = FFH, G = FFH, B = FFH)
+# 02H             Built-in Red (R = FFH, G = 00H, B = 00H)
+# 03H             Built-in Green (R = 00H, G = FFH, B = 00H)
+# 04H             Built-in Blue (R = 00H, G = 00H, B = FFH)
+# 05H             Built-in Yellow (R = FFH, G = FFH, B = 00H)
+# 06H             Built-in Magenta (R = FFH, G = 00H, B = FFH)
+# 07H             Built-in Cyan (R = 00H, G = FFH, B = FFH)
+# 08H             First user-defined colour from the PALETTE record (entry 0 from record colour list)
+# .........................
+# 
+# 17H (BIFF3-BIFF4) Last user-defined colour from the PALETTE record (entry 15 or 55 from record colour list)
+# 3FH (BIFF5-BIFF8)
+# 
+# 18H (BIFF3-BIFF4) System window text colour for border lines (used in records XF, CF, and
+# 40H (BIFF5-BIFF8) WINDOW2 (BIFF8 only))
+# 
+# 19H (BIFF3-BIFF4) System window background colour for pattern background (used in records XF, and CF)
+# 41H (BIFF5-BIFF8)
+# 
+# 43H             System face colour (dialogue background colour)
+# 4DH             System window text colour for chart border lines
+# 4EH             System window background colour for chart areas
+# 4FH             Automatic colour for chart border lines (seems to be always Black)
+# 50H             System ToolTip background colour (used in note objects)
+# 51H             System ToolTip text colour (used in note objects)
+# 7FFFH           System window text colour for fonts (used in records FONT, EFONT, and CF)
+class PaletteRecord < BiffRecord
+  RECORD_ID = 0x0092
+end
+
+# This  record  is  located  in  the workbook globals area and represents
+# a  sheet  inside  of  the  workbook. For each sheet a BOUNDSHEET record
+# is  written.  It  stores  the sheet name and a stream offset to the BOF
+# record    within   the   workbook   stream.  The  record  is also known
+# as BUNDLESHEET.
+# 
+# Record BOUNDSHEET, BIFF5-BIFF8:
+# Offset  Size    Contents
+# 0       4       Absolute stream position of the BOF record of the sheet represented by this record. This
+#                 field is never encrypted in protected files.
+# 4       1       Visibility:
+#                     00H = Visible
+#                     01H = Hidden
+#                     02H = Strong hidden
+# 5       1       Sheet type:
+#                     00H = Worksheet
+#                     02H = Chart
+#                     06H = Visual Basic module
+# 6       var.    Sheet name:
+#                     BIFF5/BIFF7: Byte string, 8-bit string length
+#                     BIFF8: Unicode string, 8-bit string length
+class BoundSheetRecord < BiffRecord
+  RECORD_ID = 0x0085
+  
+  def initialize(stream_pos, visibility, name)
+    @record_data = [stream_pos, visibility, 0x00].pack('VCC') + [name.length, 0].pack('CC') + name
+  end
+end
+
+# Whenever  the content of a record exceeds the given limits (see table),
+# the  record  must  be  split.  Several  CONTINUE records containing the
+# additional data are added after the parent record.
+# 
+# BIFF version    Maximum data size of a record
+# BIFF2-BIFF7     2080 bytes (2084 bytes including record header)
+# BIFF8           8224 bytes (8228 bytes including record header) (0x2020)
+# 
+# Record CONTINUE, BIFF2-BIFF8:
+# Offset  Size    Contents
+# 0       var.    Data continuation of the previous record
+# 
+# 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. In each CONTINUE record it is possible
+# that  the  character  size  changes  from  8-bit  characters  to 16-bit
+# characters and vice versa.
+# 
+# Never  a  Unicode  string  is  split  until  and  including  the  first
+# character.  That means, all header fields (string length, option flags,
+# optional Rich-Text size, and optional Far-East data size) and the first
+# character  of  the string have to occur together in the leading record,
+# or  have  to  be  moved completely into the CONTINUE record. Formatting
+# runs cannot be split between their components (character index and FONT
+# record  index).  If  a string is split between two formatting runs, the
+# option flags field will not be repeated in the CONTINUE record.
+class ContinueRecord < BiffRecord
+  RECORD_ID = 0x003C
+end
+
+# This  record  contains  a  list  of  all  strings  used anywhere in the
+# workbook.  Each string occurs only once. The workbook uses indexes into
+# the list to reference the strings.
+# 
+# Record SST, BIFF8:
+# 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
+# 
+# The  first  field  of  the  SST  record  counts  the  total  occurrence
+# of  strings  in  the  workbook.  For  instance,  the string AAA is used
+# 3  times  and  the string BBB is used 2 times. The first field contains
+# 5 and the second field contains 2, followed by the two strings.
+class SSTRecord < BiffRecord
+  RECORD_ID = 0x00FC
+end
+
+# This  record  occurs  in  conjunction  with  the SST record. It is used
+# by  Excel  to create a hash table with stream offsets to the SST record
+# to optimise string search operations. Excel may not shorten this record
+# if  strings  are deleted from the shared string table, so the last part
+# might  contain  invalid  data. The stream indexes in this record divide
+# the SST into portions containing a constant number of strings.
+# 
+# Record EXTSST, BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Number of strings in a portion, this number is >=8
+# 2       var.    List of OFFSET structures for all portions. Each OFFSET contains the following data:
+#                     Offset Size Contents
+#                     0       4   Absolute stream position of first string of the portion
+#                     4       2   Position of first string of the portion inside of current record,
+#                                 including record header. This counter restarts at zero, if the SST
+#                                 record is continued with a CONTINUE record.
+#                     6       2   Not used
+class ExtSSTRecord < BiffRecord
+  RECORD_ID = 0x00FF
+  
+  def initialize(sst_stream_pos, str_placement, portions_len)
+    extsst = {}
+    abs_stream_pos = sst_stream_pos
+    str_counter = 0
+    portion_counter = 0
+    
+    while (str_counter < str_placement.length) do
+      str_chunk_num, pos_in_chunk = str_placement[str_counter]
+      if str_chunk_num != portion_counter
+        portion_counter = str_chunk_num
+        abs_stream_pos += portions_len[portion_counter-1]
+      end
+      str_stream_pos = abs_stream_pos + pos_in_chunk + 4 # header
+      extsst[str_counter] = [pos_in_chunk, str_stream_pos]
+      str_counter += 1
+    end
+  
+    exsst_str_count_delta = [8, str_placement.length*8/0x2000].max
+    @record_data = [exsst_str_count_delta].pack('v')
+    
+    str_counter = 0
+    while (str_counter < str_placement.length) do
+      @record_data += [extsst[str_counter][1], extsst[str_counter][0], 0].pack('Vvv')
+      str_counter += exsst_str_count_delta
+    end
+  end
+end
+
+
+# Record DIMENSIONS, BIFF8:
+# 
+# Offset  Size    Contents
+# 0       4       Index to first used row
+# 4       4       Index to last used row, increased by 1
+# 8       2       Index to first used column
+# 10      2       Index to last used column, increased by 1
+# 12      2       Not used
+class DimensionsRecord < BiffRecord
+  RECORD_ID = 0x0200
+  
+  def initialize(first_used_row, last_used_row, first_used_col, last_used_col)
+    @record_data = [first_used_row, last_used_row + 1, first_used_col, last_used_col + 1, 0x00].pack('V2v3')
+  end
+end
+
+
+# Record WINDOW2, BIFF8:
+# 
+# Offset  Size Contents
+# 0       2 Option flags (see below)
+# 2       2 Index to first visible row
+# 4       2 Index to first visible column
+# 6       2 Colour index of grid line colour. Note that in BIFF2-BIFF7 an RGB colour is
+#             written instead.
+# 8       2 Not used
+# 10      2 Cached magnification factor in page break preview (in percent); 0 = Default (60%)
+# 12      2 Cached magnification factor in normal view (in percent); 0 = Default (100%)
+# 14      4 Not used
+# 
+# In  BIFF8  this record stores used magnification factors for page break
+# preview  and  normal  view.  These  values  are  used  to  restore  the
+# magnification,  when the view is changed. The real magnification of the
+# currently  active  view  is  stored  in the SCL record. The type of the
+# active view is stored in the option flags field (see below).
+# 
+#  0 0001H 0 = Show formula results 1 = Show formulas
+#  1 0002H 0 = Do not show grid lines 1 = Show grid lines
+#  2 0004H 0 = Do not show sheet headers 1 = Show sheet headers
+#  3 0008H 0 = Panes are not frozen 1 = Panes are frozen (freeze)
+#  4 0010H 0 = Show zero values as empty cells 1 = Show zero values
+#  5 0020H 0 = Manual grid line colour 1 = Automatic grid line colour
+#  6 0040H 0 = Columns from left to right 1 = Columns from right to left
+#  7 0080H 0 = Do not show outline symbols 1 = Show outline symbols
+#  8 0100H 0 = Keep splits if pane freeze is removed 1 = Remove splits if pane freeze is removed
+#  9 0200H 0 = Sheet not selected 1 = Sheet selected (BIFF5-BIFF8)
+# 10 0400H 0 = Sheet not visible 1 = Sheet visible (BIFF5-BIFF8)
+# 11 0800H 0 = Show in normal view 1 = Show in page break preview (BIFF8)
+# 
+# The freeze flag specifies, if a following PANE record describes unfrozen or frozen panes.
+#
+#   *** This class appends the optional SCL record ***
+#
+#   Record SCL, BIFF4-BIFF8:
+#
+#   This record stores the magnification of the active view of the current worksheet.
+#   In BIFF8 this can be either the normal view or the page break preview.
+#   This is determined in the WINDOW2 record. The SCL record is part of the
+#   Sheet View Settings Block.
+#
+#   Offset  Size    Contents
+#   0       2       Numerator of the view magnification fraction (num)
+#   2       2       Denumerator [denominator] of the view magnification fraction (den)
+#   The magnification is stored as reduced fraction. The magnification results from num/den.
+#
+#   SJM note: Excel expresses (e.g.) 25% in reduced form i.e. 1/4. Reason unknown. This code
+#   writes 25/100, and Excel is happy with that.
+class Window2Record < BiffRecord
+  RECORD_ID = 0x023E
+  
+  def initialize(options, first_visible_row, first_visible_col, grid_colour, preview_magn, normal_magn, scl_magn)
+    scl_rec = ''
+    scl_rec = [0x00A0, 4, scl_magn, 100].pack('v4') unless scl_magn == 0
+    
+    args = [options, first_visible_row, first_visible_col, grid_colour, 0x00, preview_magn, normal_magn, 0x00]
+    @record_data = args.pack('v7V') + scl_rec
+  end
+end
+
+# This record stores the position of window panes. It is part of the Sheet
+# View Settings Block. If the sheet does not contain any splits, this
+# record will not occur.
+# A sheet can be split in two different ways, with unfrozen panes or with
+# frozen panes. A flag in the WINDOW2 record specifies, if the panes are
+# frozen, which affects the contents of this record.
+# 
+# Record PANE, BIFF2-BIFF8:
+# Offset      Size        Contents
+# 0           2           Position of the vertical split
+#                         (px, 0 = No vertical split):
+#                         Unfrozen pane: Width of the left pane(s)
+#                         (in twips = 1/20 of a point)
+#                         Frozen pane: Number of visible
+#                         columns in left pane(s)
+# 2           2           Position of the horizontal split
+#                         (py, 0 = No horizontal split):
+#                         Unfrozen pane: Height of the top pane(s)
+#                         (in twips = 1/20 of a point)
+#                         Frozen pane: Number of visible
+#                         rows in top pane(s)
+# 4           2           Index to first visible row
+#                         in bottom pane(s)
+# 6           2           Index to first visible column
+#                         in right pane(s)
+# 8           1           Identifier of pane with active
+#                         cell cursor
+# [9]         1           Not used (BIFF5-BIFF8 only, not written
+#                         in BIFF2-BIFF4)
+# 
+# If the panes are frozen, pane†0 is always active, regardless
+# of the cursor position. The correct identifiers for all possible
+# combinations of visible panes are shown in the following pictures.
+# 
+# px = 0, py = 0                  px = 0, py > 0
+# --------------------------      ------------|-------------
+# |                        |      |                        |
+# |                        |      |           3            |
+# |                        |      |                        |
+# -           3            -      --------------------------
+# |                        |      |                        |
+# |                        |      |           2            |
+# |                        |      |                        |
+# --------------------------      ------------|-------------
+# 
+# px > 0, py = 0                  px > 0, py > 0
+# ------------|-------------      ------------|-------------
+# |           |            |      |           |            |
+# |           |            |      |     3     |      2     |
+# |           |            |      |           |            |
+# -     3     |      1     -      --------------------------
+# |           |            |      |           |            |
+# |           |            |      |     1     |      0     |
+# |           |            |      |           |            |
+# ------------|-------------      ------------|-------------
+class PanesRecord < BiffRecord
+  RECORD_ID = 0x0041
+  
+  def initialize(px, py, first_row_bottom, first_col_right, active_pane)
+    @record_data = [px, py, first_row_bottom, first_col_right, active_pane].pack('v5')
+  end
+end
+
+
+# This  record  contains  the properties of a single row in a sheet. Rows
+# and cells in a sheet are divided into blocks of 32 rows.
+# 
+# Record ROW, BIFF3-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Index of this row
+# 2       2       Index to column of the first cell which is described by a cell record
+# 4       2       Index to column of the last cell which is described by a cell record,
+#                 increased by 1
+# 6       2       Bit     Mask    Contents
+#                 14-0    7FFFH   Height of the row, in twips = 1/20 of a point
+#                 15      8000H   0 = Row has custom height; 1 = Row has default height
+# 8       2       Not used
+# 10      2       In BIFF3-BIFF4 this field contains a relative offset
+#                 to calculate stream position of the first cell record
+#                 for this row. In BIFF5-BIFF8 this field is not used
+#                 anymore, but the DBCELL record instead.
+# 12      4       Option flags and default row formatting:
+#                 Bit     Mask        Contents
+#                 2-0     00000007H   Outline level of the row
+#                 4       00000010H   1 = Outline group starts or ends here (depending
+#                                     on where the outline buttons are located,
+#                                     see WSBOOL record), and is collapsed
+#                 5       00000020H   1 = Row is hidden (manually, or by a filter or outline group)
+#                 6       00000040H   1 = Row height and default font height do not match
+#                 7       00000080H   1 = Row has explicit default format (fl)
+#                 8       00000100H   Always 1
+#                 27-16   0FFF0000H   If fl=1: Index to default XF record
+#                 28      10000000H   1 = Additional space above the row. This flag is set,
+#                                     if the upper border of at least one cell in this row
+#                                     or if the lower border of at least one cell in the row
+#                                     above is formatted with a thick line style.
+#                                     Thin and medium line styles are not taken into account.
+#                 29      20000000H   1 = Additional space below the row. This flag is set,
+#                                     if the lower border of at least one cell in this row
+#                                     or if the upper border of at least one cell in the row
+#                                     below is formatted with a medium or thick line style.
+#                                     Thin line styles are not taken into account.
+class RowRecord < BiffRecord
+  RECORD_ID = 0x0208
+  
+  def initialize(index, first_col, last_col, height_options, options)
+    @record_data = [index, first_col, last_col + 1, height_options, 0x00, 0x00, options].pack('v6V')
+  end
+end
+
+# This record represents a cell that contains a string. It replaces the
+# LABEL record and RSTRING record used in BIFF2-BIFF7.
+class LabelSSTRecord < BiffRecord
+  RECORD_ID = 0x00FD
+  
+  def initialize(row, col, xf_idx, sst_idx)
+    @record_data = [row, col, xf_idx, sst_idx].pack('v3V')
+  end
+end
+
+# This record contains all merged cell ranges of the current sheet.
+# 
+# Record MERGEDCELLS, BIFF8:
+# 
+# Offset  Size    Contents
+# 0       var.    Cell range address list with all merged ranges
+# 
+# ------------------------------------------------------------------
+# 
+# A cell range address list consists of a field with the number of ranges
+# and the list of the range addresses.
+# 
+# Cell range address list, BIFF8:
+# 
+# Offset  Size            Contents
+# 0       2               Number of following cell range addresses (nm)
+# 2       8*nm            List of nm cell range addresses
+# 
+# ---------------------------------------------------------------------
+# Cell range address, BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Index to first row
+# 2       2       Index to last row
+# 4       2       Index to first column
+# 6       2       Index to last column
+class MergedCellsRecord < BiffRecord
+  RECORD_ID = 0x00E5
+  
+  def initialize(merged_list)
+    @record_data = ''
+    
+    i = merged_list.length - 1
+    while i >= 0 do
+      j = 0
+      merged = ''
+      while (i >= 0) && (j < 0x403) do
+        r1, r2, c1, c2 = merged_list[i]
+        merged += [r1, r2, c1, c2].pack('v4')
+        i -= 1
+        j += 1
+      end
+      @record_data += [RECORD_ID, merged.length + 2, j].pack('v3') + merged
+    end
+  end
+
+  # for some reason Excel doesn't use CONTINUE
+  def to_biff
+    @record_data
+  end
+end
+
+# This  record  represents  a  cell  range  of empty cells. All cells are
+# located in the same row.
+# 
+# Record MULBLANK, BIFF5-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Index to row
+# 2       2       Index to first column (fc)
+# 4       2*nc    List of nc=lc-fc+1 16-bit indexes to XF records
+# 4+2*nc  2       Index to last column (lc)
+class MulBlankRecord < BiffRecord
+  RECORD_ID = 0x00BE
+  
+  def initialize(row, first_col, last_col, xf_index)
+    blanks_count = last_col-first_col+1
+    blanks = ([xf_index]*blanks_count).pack('v*')
+    @record_data = [row, first_col].pack('v2') + blanks + [last_col].pack('v')
+  end
+end
+
+# This  record  represents  an empty cell.
+# 
+# Record BLANK, BIFF5-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Index to row
+# 2       2       Index to first column (fc)
+# 4       2       indexes to XF record
+class BlankRecord < BiffRecord
+  RECORD_ID = 0x0201
+  
+  def initialize(row, col, xf_index)
+    @record_data = [row, col, xf_index].pack('v3')
+  end
+end
+
+# This record represents a cell that contains an RK value (encoded integer or
+# floating-point value). If a floating-point value cannot be encoded to an RK value,
+# a NUMBER record will be written.
+class RKRecord < BiffRecord
+  RECORD_ID = 0x027E
+
+  def initialize(row, col, xf_index, rk_encoded)
+    @record_data = [row, col, xf_index, rk_encoded].pack('v3V')
+  end
+end
+
+# This record represents a cell that contains an IEEE-754 floating-point value.
+class NumberRecord < BiffRecord
+  RECORD_ID = 0x0203
+
+  def initialize(row, col, xf_index, number)
+    @record_data = [row, col, xf_index, number].pack('v3E')
+  end
+end
+
+# This record represents a cell that contains a boolean or error value. '<3HBB'
+class BoolErrRecord < BiffRecord
+  RECORD_ID = 0x0205
+  
+  def initialize(row, col, xf_index, number, is_error)
+    @record_data = [row, col, xf_index, number, is_error].pack('v3C2')
+  end
+end
+
+# Offset Size Contents
+# 0      2    Index to row
+# 2      2    Index to column
+# 4      2    Index to XF record
+# 6      8    Result of the formula
+# 14     2    Option flags:
+#             Bit Mask    Contents
+#             0   0001H   1 = Recalculate always
+#             1   0002H   1 = Calculate on open
+#             3   0008H   1 = Part of a shared formula
+# 16     4    Not used
+# 20     var. Formula data (RPN token array)
+### @export "formula-record"
+class FormulaRecord < BiffRecord
+  RECORD_ID = 0x0006
+
+  def initialize(row, col, xf_index, rpn, calc_flags = 0)
+    @record_data = [row, col, xf_index, 0xFFFF000000000003, calc_flags & 0x03, 0].pack('v3QvV') + rpn
+  end
+end
+### @end
+
+# This record contains information about the layout of outline symbols.
+# 
+# Record GUTS, BIFF3-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Width of the area to display row outlines (left of the sheet), in pixel
+# 2       2       Height of the area to display column outlines (above the sheet), in pixel
+# 4       2       Number of visible row outline levels (used row levels + 1; or 0, if not used)
+# 6       2       Number of visible column outline levels (used column levels + 1; or 0, if not used)
+class GutsRecord < BiffRecord
+  RECORD_ID = 0x0080
+
+  def initialize(row_gut_width, col_gut_height, row_visible_levels, col_visible_levels)
+    @record_data = [row_gut_width, col_gut_height, row_visible_levels, col_visible_levels].pack('v4')
+  end
+end
+
+# This  record stores a 16 bit value with Boolean options for the current
+# sheet.  From BIFF5 on the "Save external linked values" option is moved
+# to the record BOOKBOOL.
+# 
+# Option flags of record WSBOOL, BIFF3-BIFF8:
+# 
+# Bit     Mask    Contents
+# 0       0001H   0 = Do not show automatic page breaks
+#                 1 = Show automatic page breaks
+# 4       0010H   0 = Standard sheet
+#                 1 = Dialogue sheet (BIFF5-BIFF8)
+# 5       0020H   0 = No automatic styles in outlines
+#                 1 = Apply automatic styles to outlines
+# 6       0040H   0 = Outline buttons above outline group
+#                 1 = Outline buttons below outline group
+# 7       0080H   0 = Outline buttons left of outline group
+#                 1 = Outline buttons right of outline group
+# 8       0100H   0 = Scale printout in percent
+#                 1 = Fit printout to number of pages
+# 9       0200H   0 = Save external linked values (BIFF3?BIFF4 only)
+#                 1 = Do not save external linked values (BIFF3?BIFF4 only)
+# 10      0400H   0 = Do not show row outline symbols
+#                 1 = Show row outline symbols
+# 11      0800H   0 = Do not show column outline symbols
+#                 1 = Show column outline symbols
+# 13-12   3000H   These flags specify the arrangement of windows.
+#                 They are stored in BIFF4 only.
+#                 00 = Arrange windows tiled
+#                 01 = Arrange windows horizontal
+#                 10 = Arrange windows vertical112 = Arrange windows cascaded
+# The following flags are valid for BIFF4-BIFF8 only:
+# 14      4000H   0 = Standard expression evaluation
+#                 1 = Alternative expression evaluation
+# 15      8000H   0 = Standard formula entries
+#                 1 = Alternative formula entries
+class WSBoolRecord < BiffRecord
+  RECORD_ID = 0x0081
+
+  def initialize(options)
+    @record_data = [options].pack('v')
+  end
+end
+
+# This record specifies the width for a given range of columns.
+# If a column does not have a corresponding COLINFO record,
+# the width specified in the record STANDARDWIDTH is used. If
+# this record is also not present, the contents of the record
+# DEFCOLWIDTH is used instead.
+# This record also specifies a default XF record to use for
+# cells in the columns that are not described by any cell record
+# (which contain the XF index for that cell). Additionally,
+# the option flags field contains hidden, outline, and collapsed
+# options applied at the columns.
+# 
+# Record COLINFO, BIFF3-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Index to first column in the range
+# 2       2       Index to last column in the range
+# 4       2       Width of the columns in 1/256 of the width of the zero character, using default font
+#                 (first FONT record in the file)
+# 6       2       Index to XF record for default column formatting
+# 8       2       Option flags:
+#                 Bits    Mask    Contents
+#                 0       0001H   1 = Columns are hidden
+#                 10-8    0700H   Outline level of the columns (0 = no outline)
+#                 12      1000H   1 = Columns are collapsed
+# 10      2       Not used
+class ColInfoRecord < BiffRecord
+  RECORD_ID = 0x007D
+
+  def initialize(first_col, last_col, width, xf_index, options)
+    @record_data = [first_col, last_col, width, xf_index, options, 0].pack('v6')
+  end
+end
+
+# This record is part of the Calculation Settings Block.
+# It specifies whether to calculate formulas manually,
+# automatically or automatically except for multiple table operations.
+# 
+# Record CALCMODE, BIFF2-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       FFFFH = automatic except for multiple table operations
+#                 0000H = manually
+#                 0001H = automatically (default)
+class CalcModeRecord < BiffRecord
+  RECORD_ID = 0x000D
+
+  def initialize(calc_mode)
+    @record_data = [calc_mode].pack('v')
+  end
+end
+
+# This record is part of the Calculation Settings Block. It specifies the maximum
+# number of times the formulas should be iteratively calculated. This is a fail-safe
+# against mutually recursive formulas locking up a spreadsheet application.
+# 
+# Record CALCCOUNT, BIFF2-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Maximum number of iterations allowed in circular references
+class CalcCountRecord < BiffRecord
+  RECORD_ID = 0x000C
+
+  def initialize(calc_count)
+    @record_data = [calc_count].pack('v')
+  end
+end
+
+# This record is part of the Calculation Settings Block.
+# It stores which method is used to show cell addresses in formulas.
+# The ìRCî mode uses numeric indexes for rows and columns,
+# i.e. ìR(1)C(-1)î, or ìR1C1:R2C2î.
+# The ìA1î mode uses characters for columns and numbers for rows,
+# i.e. ìB1î, or ì$A$1:$B$2î.
+# 
+# Record REFMODE, BIFF2-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       0 = RC mode; 1 = A1 mode
+class RefModeRecord < BiffRecord
+  RECORD_ID = 0x00F
+
+  def initialize(ref_mode)
+    @record_data = [ref_mode].pack('v')
+  end
+end
+
+# This record is part of the Calculation Settings Block.
+# It stores if iterations are allowed while calculating recursive formulas.
+# 
+# Record ITERATION, BIFF2-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       0 = Iterations off; 1 = Iterations on
+class IterationRecord < BiffRecord
+  RECORD_ID = 0x011
+
+  def initialize(iterations_on)
+    @record_data = [iterations_on].pack('v')
+  end
+end
+
+# This record is part of the Calculation Settings Block.
+# It stores the maximum change of the result to exit an iteration.
+# 
+# Record DELTA, BIFF2-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       8       Maximum change in iteration
+#                 (IEEE 754 floating-point value,
+#                  64bit double precision)
+class DeltaRecord < BiffRecord
+  RECORD_ID = 0x010
+
+  def initialize(delta)
+    @record_data = [delta].pack('E')
+  end
+end
+
+# This record is part of the Calculation Settings Block.
+# It contains the ìRecalculate before saveî option in
+# Excel's calculation settings dialogue.
+# 
+# Record SAVERECALC, BIFF3-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       0 = Do not recalculate;
+#                 1 = Recalculate before saving the document
+class SaveRecalcRecord < BiffRecord
+  RECORD_ID = 0x05F
+
+  def initialize(recalc)
+    @record_data = [recalc].pack('v')
+  end
+end
+
+# This record stores if the row and column headers
+# (the areas with row numbers and column letters) will be printed.
+# 
+# Record PRINTHEADERS, BIFF2-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       0 = Do not print row/column headers;
+#                 1 = Print row/column headers
+class PrintHeadersRecord < BiffRecord
+  RECORD_ID = 0x02A
+
+  def initialize(print_headers)
+    @record_data = [print_headers].pack('v')
+  end
+end
+
+# This record stores if sheet grid lines will be printed.
+# 
+# Record PRINTGRIDLINES, BIFF2-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       0 = Do not print sheet grid lines;
+#                 1 = Print sheet grid lines
+class PrintGridLinesRecord < BiffRecord
+  RECORD_ID = 0x02B
+
+  def initialize(print_grid)
+    @record_data = [print_grid].pack('v')
+  end
+end
+
+# This record specifies if the option to print sheet grid lines
+# (record PRINTGRIDLINES) has ever been changed.
+# 
+# Record GRIDSET, BIFF3-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       0 = Print grid lines option never changed
+#                 1 = Print grid lines option changed
+class GridSetRecord < BiffRecord
+  RECORD_ID = 0x082
+
+  def initialize(print_grid_changed)
+    @record_data = [print_grid_changed].pack('v')
+  end
+end
+
+# This record specifies the default height and default flags
+# for rows that do not have a corresponding ROW record.
+# 
+# Record DEFAULTROWHEIGHT, BIFF3-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Option flags:
+#                 Bit Mask    Contents
+#                 0   0001H   1 = Row height and default font height do not match
+#                 1   0002H   1 = Row is hidden
+#                 2   0004H   1 = Additional space above the row
+#                 3   0008H   1 = Additional space below the row
+# 2       2       Default height for unused rows, in twips = 1/20 of a point
+class DefaultRowHeight < BiffRecord
+  RECORD_ID = 0x0225
+
+  def initialize(options, def_height)
+    @record_data = [options, def_height].pack('v2')
+  end
+end
+
+# This record specifies the default column width for columns that
+# do not have a specific width set using the record COLINFO or COLWIDTH.
+# This record has no effect, if a STANDARDWIDTH record is present in the file.
+# 
+# Record DEFCOLWIDTH, BIFF2-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       Column width in characters, using the width of the zero
+#                 character from default font (first FONT record in the file)
+class DefColWidthRecord < BiffRecord
+  RECORD_ID = 0x0055
+
+  def initialize(def_width)
+    @record_data = [def_width].pack('v')
+  end
+end
+
+# This  record  is  part  of  the  Page  Settings  Block. It contains all
+# horizontal manual page breaks.
+# 
+# Record HORIZONTALPAGEBREAKS, BIFF8:
+# Offset  Size  Contents
+# 0       2     Number of following row index structures (nm)
+# 2       6nm   List of nm row index structures. Each row index
+#               structure contains:
+#                 Offset  Size    Contents
+#                 0       2       Index to first row below the page break
+#                 2       2       Index to first column of this page break
+#                 4       2       Index to last column of this page break
+# 
+# The row indexes in the lists must be ordered ascending.
+# If in BIFF8 a row contains several page breaks, they must be ordered
+# ascending by start column index.
+class HorizontalPageBreaksRecord < BiffRecord
+  RECORD_ID = 0x001B
+
+  def initialize(breaks_list)
+    @record_data = [breaks_list.length].pack('v')
+    breaks_list.each do |r, c1, c2|
+      @record_data += [r, c1, c2].pack('v3')
+    end
+  end
+end
+
+# This  record  is  part  of  the  Page  Settings  Block. It contains all
+# vertical manual page breaks.
+# 
+# Record VERTICALPAGEBREAKS, BIFF8:
+# Offset  Size  Contents
+# 0       2     Number of following column index structures (nm)
+# 2       6nm   List of nm column index structures. Each column index
+#               structure contains:
+#                 Offset  Size    Contents
+#                 0       2       Index to first column following the page
+#                                 break
+#                 2       2       Index to first row of this page break
+#                 4       2       Index to last row of this page break
+# 
+# The column indexes in the lists must be ordered ascending.
+# If in BIFF8 a column contains several page breaks, they must be ordered
+# ascending by start row index.
+class VerticalPageBreaksRecord < BiffRecord
+  RECORD_ID = 0x001A
+
+  def initialize(breaks_list)
+    @record_data = [breaks_list.length].pack('v')
+    breaks_list.each do |c, r1, r2|
+      @record_data += [c, r1, r2].pack('v3')
+    end
+  end
+end
+
+# This record is part of the Page Settings Block. It specifies the
+# page  header  string  for  the current worksheet. If this record is not
+# present  or  completely  empty  (record  size is 0), the sheet does not
+# contain a page header.
+# 
+# Record HEADER for non-empty page header, BIFF2-BIFF8:
+# Offset      Size    Contents
+# 0           var.    Page header string
+#                     BIFF2-BIFF7:    Non-empty byte string, 8bit string
+#                     length
+#                     BIFF8: Non-empty Unicode string, 16bit string length
+# The  header  string may contain special commands, i.e. placeholders for
+# the  page  number,  current  date, or text formatting attributes. These
+# fields  are  represented  by  single  letters (exception: font name and
+# size,  see  below)  with  a  leading  ampersand ("&"). If the ampersand
+# is  part  of the regular header text, it will be duplicated ("&&"). The
+# page  header is divided into 3 sections: the left, the centred, and the
+# right  section.  Each  section  is introduced by a special command. All
+# text  and all commands following are part of the selected section. Each
+# section  starts  with the text formatting specified in the default font
+# (first  FONT  record  in  the  file). Active formatting attributes from
+# a previous section do not go into the next section.
+# 
+# The following table shows all available commands:
+# 
+# Command         Contents
+# &&              The "&" character itself
+# &L              Start of the left section
+# &C              Start of the centred section
+# &R              Start of the right section
+# &P              Current page number
+# &N              Page count
+# &D              Current date
+# &T              Current time
+# &A              Sheet name (BIFF5-BIFF8)
+# &F              File name without path
+# &Z              File path without file name (BIFF8X)
+# &G              Picture (BIFF8X)
+# &B              Bold on/off (BIFF2-BIFF4)
+# &I              Italic on/off (BIFF2-BIFF4)
+# &U              Underlining on/off
+# &E              Double underlining on/off (BIFF5-BIFF8)
+# &S              Strikeout on/off
+# &X              Superscript on/off (BIFF5-BIFF8)
+# &Y              Subscript on/off (BIFF5-BIFF8)
+# &"<fontname>"   Set new font <fontname>
+# &"<fontname>,<fontstyle>"
+#                 Set new font with specified style <fontstyle>.
+#                 The style <fontstyle> is in most cases one of
+#                 "Regular", "Bold", "Italic", or "Bold Italic".
+#                 But this setting is dependent on the used font,
+#                 it may differ (localised style names, or "Standard",
+#                 "Oblique", ...). (BIFF5-BIFF8)
+# &<fontheight>   Set font height in points (<fontheight> is a decimal value).
+#                 If this command is followed by a plain number to be printed
+#                 in the header, it will be separated from the font height
+#                 with a space character.
+class HeaderRecord < BiffRecord
+  RECORD_ID = 0x0014
+
+  def initialize(str)
+    @record_data = [str.length, 0].pack('vC') + str
+  end
+end
+
+# Semantic is equal to HEADER record
+class FooterRecord < BiffRecord
+  RECORD_ID = 0x0015
+
+  def initialize(str)
+    @record_data = [str.length, 0].pack('vC') + str
+  end
+end
+
+# This  record  is  part  of the Page Settings Block. It specifies if the
+# sheet is centred horizontally when printed.
+# 
+# Record HCENTER, BIFF3-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       0 = Print sheet left aligned
+#                 1 = Print sheet centred horizontally
+class HCenterRecord < BiffRecord
+  RECORD_ID = 0x0083
+
+  def initialize(is_horz_center)
+    @record_data = [is_horz_center].pack('v')
+  end
+end
+
+# This  record  is  part  of the Page Settings Block. It specifies if the
+# sheet is centred vertically when printed.
+# 
+# Record VCENTER, BIFF3-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       2       0 = Print sheet aligned at top page border
+#                 1 = Print sheet vertically centred
+class VCenterRecord < BiffRecord
+  RECORD_ID = 0x0084
+
+  def initialize(is_vert_center)
+    @record_data = [is_vert_center].pack('v')
+  end
+end
+
+# This  record  is  part of the Page Settings Block. It contains the left
+# page margin of the current worksheet.
+# 
+# Record LEFTMARGIN, BIFF2-BIFF8:
+# 
+# Offset  Size    Contents
+# 0       8       Left page margin in inches
+#                 (IEEE 754 floating-point value, 64bit double precision)
+class LeftMarginRecord < BiffRecord
+  RECORD_ID = 0x0026
+
+  def initialize(margin)
+    @record_data = [margin].pack('E')
+  end
+end
+
+# This  record  is  part of the Page Settings Block. It contains the right
+# page margin of the current worksheet.
+# 
+# Offset  Size    Contents
+# 0       8       Right page margin in inches
+#                 (IEEE 754 floating-point value, 64?bit double precision)
+class RightMarginRecord < BiffRecord
+  RECORD_ID = 0x0027
+
+  def initialize(margin)
+    @record_data = [margin].pack('E')
+  end
+end
+
+# This  record  is  part of the Page Settings Block. It contains the top
+# page margin of the current worksheet.
+# 
+# Offset  Size    Contents
+# 0       8       Top page margin in inches
+#                 (IEEE 754 floating-point value, 64?bit double precision)
+class TopMarginRecord < BiffRecord
+  RECORD_ID = 0x0028
+
+  def initialize(margin)
+    @record_data = [margin].pack('E')
+  end
+end
+
+# This  record  is  part of the Page Settings Block. It contains the bottom
+# page margin of the current worksheet.
+# 
+# Offset  Size    Contents
+# 0       8       Bottom page margin in inches
+#                 (IEEE 754 floating-point value, 64?bit double precision)
+class BottomMarginRecord < BiffRecord
+  RECORD_ID = 0x0029
+
+  def initialize(margin)
+    @record_data = [margin].pack('E')
+  end
+end
+
+# This   record   is  part of the Page Settings Block. It stores the page
+# format   settings   of   the  current sheet. The pages may be scaled in
+# percent   or  by  using  an  absolute  number of pages. This setting is
+# located   in  the  WSBOOL  record.  If  pages  are  scaled in  percent,
+# the   scaling  factor  in  this  record is used, otherwise the "Fit  to
+# pages"  values. One of the "Fit to pages" values may be 0. In this case
+# the sheet is scaled to fit only to the other value.
+# 
+# Record SETUP, BIFF5-BIFF8:
+# 
+# Offset      Size    Contents
+# 0           2       Paper size (see below)
+# 2           2       Scaling factor in percent
+# 4           2       Start page number
+# 6           2       Fit worksheet width to this number of pages
+#                     (0 = use as many as needed)
+# 8           2       Fit worksheet height to this number of pages
+#                     (0 = use as many as needed)
+# 10          2       Option flags:
+#                     Bit     Mask        Contents
+#                     0       0001H       0 = Print pages in columns
+#                                         1 = Print pages in rows
+#                     1       0002H       0 = Landscape
+#                                         1 = Portrait
+#                     2       0004H       1 = Paper size, scaling factor,
+#                                         paper orientation (portrait/landscape),
+#                                         print resolution and number of copies
+#                                         are not initialised
+#                     3       0008H       0 = Print coloured
+#                                         1 = Print black and white
+#                     4       0010H       0 = Default print quality
+#                                         1 = Draft quality
+#                     5       0020H       0 = Do not print cell notes
+#                                         1 = Print cell notes
+#                     6       0040H       0 = Paper orientation setting is valid
+#                                         1 = Paper orientation setting not
+#                                         initialised
+#                     7       0080H       0 = Automatic page numbers
+#                                         1 = Use start page number
+#                     The following flags are valid for BIFF8 only:
+#                     9       0200H       0 = Print notes as displayed
+#                                         1 = Print notes at end of sheet
+#                     11-10   0C00H       00 = Print errors as displayed
+#                                         01 = Do not print errors
+#                                         10 = Print errors as "--"
+#                                         11 = Print errors as "#N/A!"
+# 12          2       Print resolution in dpi
+# 14          2       Vertical print resolution in dpi
+# 16          8       Header margin (IEEE 754 floating-point value,
+#                     64bit double precision)
+# 24          8       Footer margin (IEEE 754 floating-point value,
+#                     64bit double precision)
+# 32          2       Number of copies to print
+# 
+# 
+# PAPER TYPES:
+# 
+# Index   Paper type              Paper size
+# 0       Undefined
+# 1       Letter                  8 1/2" x 11"
+# 2       Letter small            8 1/2" x 11"
+# 3       Tabloid                 11" x 17"
+# 4       Ledger                  17" x 11"
+# 5       Legal                   8 1/2" x 14"
+# 6       Statement               5 1/2" x 8 1/2"
+# 7       Executive               7 1/4" x 10 1/2"
+# 8       A3                      297mm x 420mm
+# 9       A4                      210mm x 297mm
+# 10      A4 small                210mm x 297mm
+# 11      A5                      148mm x 210mm
+# 12      B4 (JIS)                257mm x 364mm
+# 13      B5 (JIS)                182mm x 257mm
+# 14      Folio                   8 1/2" x 13"
+# 15      Quarto                  215mm x 275mm
+# 16      10x14                   10" x 14"
+# 17      11x17                   11" x 17"
+# 18      Note                    8 1/2" x 11"
+# 19      Envelope #9             3 7/8" x 8 7/8"
+# 20      Envelope #10            4 1/8" x 9 1/2"
+# 21      Envelope #11            4 1/2" x 10 3/8"
+# 22      Envelope #12            4 3/4" x 11"
+# 23      Envelope #14            5" x 11 1/2"
+# 24      C                       17" x 22"
+# 25      D                       22" x 34"
+# 26      E                       34" x 44"
+# 27      Envelope DL             110mm x 220mm
+# 28      Envelope C5             162mm x 229mm
+# 29      Envelope C3             324mm x 458mm
+# 30      Envelope C4             229mm x 324mm
+# 31      Envelope C6             114mm x 162mm
+# 32      Envelope C6/C5          114mm x 229mm
+# 33      B4 (ISO)                250mm x 353mm
+# 34      B5 (ISO)                176mm x 250mm
+# 35      B6 (ISO)                125mm x 176mm
+# 36      Envelope Italy          110mm x 230mm
+# 37      Envelope Monarch        3 7/8" x 7 1/2"
+# 38      63/4 Envelope           3 5/8" x 6 1/2"
+# 39      US Standard Fanfold     14 7/8" x 11"
+# 40      German Std. Fanfold     8 1/2" x 12"
+# 41      German Legal Fanfold    8 1/2" x 13"
+# 42      B4 (ISO)                250mm x 353mm
+# 43      Japanese Postcard       100mm x 148mm
+# 44      9x11                    9" x 11"
+# 45      10x11                   10" x 11"
+# 46      15x11                   15" x 11"
+# 47      Envelope Invite         220mm x 220mm
+# 48      Undefined
+# 49      Undefined
+# 50      Letter Extra            9 1/2" x 12"
+# 51      Legal Extra             9 1/2" x 15"
+# 52      Tabloid Extra           11 11/16" x 18"
+# 53      A4 Extra                235mm x 322mm
+# 54      Letter Transverse       8 1/2" x 11"
+# 55      A4 Transverse           210mm x 297mm
+# 56      Letter Extra Transv.    9 1/2" x 12"
+# 57      Super A/A4              227mm x 356mm
+# 58      Super B/A3              305mm x 487mm
+# 59      Letter Plus             8 1/2" x 12 11/16"
+# 60      A4 Plus                 210mm x 330mm
+# 61      A5 Transverse           148mm x 210mm
+# 62      B5 (JIS) Transverse     182mm x 257mm
+# 63      A3 Extra                322mm x 445mm
+# 64      A5 Extra                174mm x 235mm
+# 65      B5 (ISO) Extra          201mm x 276mm
+# 66      A2                      420mm x 594mm
+# 67      A3 Transverse           297mm x 420mm
+# 68      A3 Extra Transverse     322mm x 445mm
+# 69      Dbl. Japanese Postcard  200mm x 148mm
+# 70      A6                      105mm x 148mm
+# 71
+# 72
+# 73
+# 74
+# 75      Letter Rotated          11" x 8 1/2"
+# 76      A3 Rotated              420mm x 297mm
+# 77      A4 Rotated              297mm x 210mm
+# 78      A5 Rotated              210mm x 148mm
+# 79      B4 (JIS) Rotated        364mm x 257mm
+# 80      B5 (JIS) Rotated        257mm x 182mm
+# 81      Japanese Postcard Rot.  148mm x 100mm
+# 82      Dbl. Jap. Postcard Rot. 148mm x 200mm
+# 83      A6 Rotated              148mm x 105mm
+# 84
+# 85
+# 86
+# 87
+# 88      B6 (JIS)                128mm x 182mm
+# 89      B6 (JIS) Rotated        182mm x 128mm
+# 90      12x11                   12" x 11"
+class SetupPageRecord < BiffRecord
+  RECORD_ID = 0x00A1
+
+  def initialize(paper, scaling, start_num, fit_width_to, fit_height_to, options, hres, vres, header_margin, footer_margin, num_copies)
+    args = [paper, scaling, start_num, fit_width_to, fit_height_to, options, hres, vres, header_margin, footer_margin, num_copies]
+    @record_data = args.pack('v8E2v')
+  end
+end
+
+#   This record is part of a Link Table. It contains the name and the token
+#   array of an internal defined name. Token arrays of defined names
+#   contain tokens with aberrant token classes.
+# 
+#   Record NAME, BIFF5/BIFF7:
+#   Offset      Size    Contents
+#      0          2     Option flags, see below
+#      2          1     Keyboard shortcut (only for command macro names, see below)
+#      3          1     Length of the name (character count, ln)
+#      4          2     Size of the formula data (sz)
+#      6          2     0 = Global name, otherwise index to EXTERNSHEET record (one-based)
+#      8          2     0 = Global name, otherwise index to sheet (one-based)
+#     10          1     Length of menu text (character count, lm)
+#     11          1     Length of description text (character count, ld)
+#     12          1     Length of help topic text (character count, lh)
+#     13          1     Length of status bar text (character count, ls)
+#     14         ln     Character array of the name
+#   14+ln        sz     Formula data (RPN token array without size field, 4)
+# 14+ln+sz       lm     Character array of menu text
+#    var.        ld     Character array of description text
+#    var.        lh     Character array of help topic text
+#    var.        ls     Character array of status bar text
+# 
+#   Record NAME, BIFF8:
+#   Offset      Size Contents
+#      0          2  Option flags, see below
+#      2          1  Keyboard shortcut (only for command macro names, see below)
+#      3          1  Length of the name (character count, ln)
+#      4          2  Size of the formula data (sz)
+#      6          2  Not used
+#      8          2  0 = Global name, otherwise index to sheet (one-based)
+#     10          1  Length of menu text (character count, lm)
+#     11          1  Length of description text (character count, ld)
+#     12          1  Length of help topic text (character count, lh)
+#     13          1  Length of status bar text (character count, ls)
+#     14        var. Name (Unicode string without length field, 3.4)
+#    var.        sz  Formula data (RPN token array without size field, 4)
+#   [var.]      var. (optional, only if lm > 0) Menu text (Unicode string without length field, 3.4)
+#   [var.]      var. (optional, only if ld > 0) Description text (Unicode string without length field, 3.4)
+#   [var.]      var. (optional, only if lh > 0) Help topic text (Unicode string without length field, 3.4)
+#   [var.]      var. (optional, only if ls > 0) Status bar text (Unicode string without length field, 3.4)
+class NameRecord < BiffRecord
+  RECORD_ID = 0x0018
+
+  def initialize(options, keyboard_shortcut, name, sheet_index, rpn, menu_text='', desc_text='', help_text='', status_text='')
+    if name.is_a?(Integer)
+      unicode_name = [name].pack('c')
+    else
+      unicode_name = name
+    end
+    
+    args = [options, keyboard_shortcut, unicode_name.length, rpn.length]
+    args += [0x0000, sheet_index, 0x00]
+    args += [menu_text.length, desc_text.length, help_text.length, status_text.length]
+    args += [unicode_name, rpn]
+    
+    @record_data = args.pack('vCCv vvC vvvv b*') + menu_text + desc_text + help_text + status_text
+  end
+end
+
+# In BIFF8 the record stores a list with indexes to SUPBOOK
+# records (list of REF structures, 6.100). See 5.10.3 for 
+# details about external references in BIFF8.
+# 
+# Record EXTERNSHEET, BIFF8:
+# Offset          Size      Contents
+#    0             2        Number of following REF structures (nm)
+#    2           6nm        List of nm REF structures. Each REF contains the following data:
+#                           Offset     Size     Contents
+#                              0         2      Index to SUPBOOK record
+#                              2         2      Index to first SUPBOOK sheet
+#                              4         2      Index to last SUPBOOK sheet
+class ExternSheetRecord < BiffRecord
+  RECORD_ID = 0x0017
+
+  def initialize(refs = [])
+    # do we always need this ref? or only if there are no refs?
+    # AN: I am assuming only needed if no other refs TODO test
+    refs = [[0,0,0]] if refs.empty?
+    ref_data = refs.collect {|r| r.pack('v3')}.join
+    @record_data = [refs.length].pack('v') + ref_data
+  end
+end
+
+# This record mainly stores the URL of an external document
+# and a list of sheet names inside this document. Furthermore
+# it is used to store DDE and OLE object links, or to indicate
+# an internal 3D reference or an add-in function. See 5.10.3
+# for details about external references in BIFF8.
+class SupBookRecord < BiffRecord
+  RECORD_ID = 0x01AE
+end
+
+# In each file occurs a SUPBOOK that is used for internal 3D
+# references. It stores the number of sheets of the own document.
+# 
+# Record SUPBOOK for 3D references, BIFF8:
+# Offset         Size   Contents
+#   0             2     Number of sheets in this document
+#   2             2     01H 04H (relict of BIFF5/BIFF7, the byte string "<04H>", see 3.9.1)
+class InternalReferenceSupBookRecord < SupBookRecord
+  def initialize(num_sheets)
+    @record_data = [num_sheets, 0x01, 0x04].pack('vCC')
+  end
+end