slayer-surpass 0.1.0

data/lib/surpass/bitmap.rb

@@ -0,0 +1,218 @@
+class ObjBmpRecord < BiffRecord
+  RECORD_ID = 0x005D    # Record identifier
+  
+  def initialize(row, col, sheet, im_data_bmp, x, y, scale_x, scale_y)
+    width = im_data_bmp.width * scale_x
+    height = im_data_bmp.height * scale_y
+    
+    col_start, x1, row_start, y1, col_end, x2, row_end, y2 = position_image(sheet, row, col, x, y, width, height)
+    
+    # Store the OBJ record that precedes an IMDATA record. This could be generalise
+    # to support other Excel objects.
+    cobj = 0x0001      # count of objects in file (set to 1)
+    ot = 0x0008        # object type. 8 = picture
+    id = 0x0001        # object id
+    grbit = 0x0614     # option flags
+    coll = col_start    # col containing upper left corner of object
+    dxl = x1            # distance from left side of cell
+    rwt = row_start     # row containing top left corner of object
+    dyt = y1            # distance from top of cell
+    colr = col_end      # col containing lower right corner of object
+    dxr = x2            # distance from right of cell
+    rwb = row_end       # row containing bottom right corner of object
+    dyb = y2            # distance from bottom of cell
+    cbmacro = 0x0000    # length of fmla structure
+    reserved1 = 0x0000  # reserved
+    reserved2 = 0x0000  # reserved
+    icvback = 0x09      # background colour
+    icvfore = 0x09      # foreground colour
+    fls = 0x00          # fill pattern
+    fauto = 0x00        # automatic fill
+    icv = 0x08          # line colour
+    lns = 0xff          # line style
+    lnw = 0x01          # line weight
+    fautob = 0x00       # automatic border
+    frs = 0x0000        # frame style
+    cf = 0x0009         # image format, 9 = bitmap
+    reserved3 = 0x0000  # reserved
+    cbpictfmla = 0x0000 # length of fmla structure
+    reserved4 = 0x0000  # reserved
+    grbit2 = 0x0001     # option flags
+    reserved5 = 0x0000  # reserved
+    
+    args = [cobj, ot, id, grbit, coll, dxl, rwt, dyt, colr, dxr, rwb, dyb, cbmacro, reserved1, reserved2, icvback, icvfore, fls, fauto, icv, lns, lnw, fautob, frs, cf, reserved3, cbpictfmla, reserved4, grbit2, reserved5]
+    @record_data = args.pack('L v12 L v C8 v L v4 L')
+  end
+  
+  # Calculate the vertices that define the position of the image as required by
+  # the OBJ record.
+  # 
+  #          +------------+------------+
+  #          |     A      |      B     |
+  #    +-----+------------+------------+
+  #    |     |(x1,y1)     |            |
+  #    |  1  |(A1)._______|______      |
+  #    |     |    |              |     |
+  #    |     |    |              |     |
+  #    +-----+----|    BITMAP    |-----+
+  #    |     |    |              |     |
+  #    |  2  |    |______________.     |
+  #    |     |            |        (B2)|
+  #    |     |            |     (x2,y2)|
+  #    +---- +------------+------------+
+  # 
+  # Example of a bitmap that covers some of the area from cell A1 to cell B2.
+  # 
+  # Based on the width and height of the bitmap we need to calculate 8 vars:
+  #     col_start, row_start, col_end, row_end, x1, y1, x2, y2.
+  # The width and height of the cells are also variable and have to be taken into
+  # account.
+  # The values of col_start and row_start are passed in from the calling
+  # function. The values of col_end and row_end are calculated by subtracting
+  # the width and height of the bitmap from the width and height of the
+  # underlying cells.
+  # The vertices are expressed as a percentage of the underlying cell width as
+  # follows (rhs values are in pixels):
+  # 
+  #        x1 = X / W *1024
+  #        y1 = Y / H *256
+  #        x2 = (X-1) / W *1024
+  #        y2 = (Y-1) / H *256
+  # 
+  #        Where:  X is distance from the left side of the underlying cell
+  #                Y is distance from the top of the underlying cell
+  #                W is the width of the cell
+  #                H is the height of the cell
+  # 
+  # Note: the SDK incorrectly states that the height should be expressed as a
+  # percentage of 1024.
+  # 
+  # col_start  - Col containing upper left corner of object
+  # row_start  - Row containing top left corner of object
+  # x1  - Distance to left side of object
+  # y1  - Distance to top of object
+  # width  - Width of image frame
+  # height  - Height of image frame
+  def position_image(sheet, row_start, col_start, x1, y1, width, height)
+    while x1 >= size_col(sheet, col_start) do
+      x1 -= size_col(sheet, col_start)
+      col_start += 1
+    end
+    
+    # Adjust start row for offsets that are greater than the row height
+    while y1 >= size_row(sheet, row_start) do
+      y1 -= size_row(sheet, row_start)
+      row_start += 1
+    end
+    
+    # Initialise end cell to the same as the start cell
+    row_end = row_start   # Row containing bottom right corner of object
+    col_end = col_start   # Col containing lower right corner of object
+    width = width + x1 - 1
+    height = height + y1 - 1
+    
+    # Subtract the underlying cell widths to find the end cell of the image
+    while (width >= size_col(sheet, col_end)) do
+      width -= size_col(sheet, col_end)
+      col_end += 1
+    end
+    
+    # Subtract the underlying cell heights to find the end cell of the image
+    while (height >= size_row(sheet, row_end)) do
+      height -= size_row(sheet, row_end)
+      row_end += 1
+    end
+    
+    # Bitmap isn't allowed to start or finish in a hidden cell, i.e. a cell
+    # with zero height or width.
+    starts_or_ends_in_hidden_cell = ((size_col(sheet, col_start) == 0) or (size_col(sheet, col_end) == 0) or (size_row(sheet, row_start) == 0) or (size_row(sheet, row_end) == 0))
+    return if starts_or_ends_in_hidden_cell
+
+    # Convert the pixel values to the percentage value expected by Excel
+    x1 = (x1.to_f / size_col(sheet, col_start) * 1024).to_i
+    y1 = (y1.to_f / size_row(sheet, row_start) * 256).to_i
+    # Distance to right side of object
+    x2 = (width.to_f / size_col(sheet, col_end) * 1024).to_i
+    # Distance to bottom of object
+    y2 = (height.to_f / size_row(sheet, row_end) * 256).to_i
+    
+    [col_start, x1, row_start, y1, col_end, x2, row_end, y2]
+  end
+  
+  def size_col(sheet, col)
+    sheet.col_width(col)
+  end
+
+  def size_row(sheet, row)
+    sheet.row_height(row)
+  end
+end
+
+class ImDataBmpRecord < BiffRecord
+  RECORD_ID = 0x007F
+  
+  attr_accessor :width
+  attr_accessor :height
+  attr_accessor :size
+  
+  # Insert a 24bit bitmap image in a worksheet. The main record required is
+  # IMDATA but it must be proceeded by a OBJ record to define its position.
+  def initialize(filename)
+    @width, @height, @size, data = process_bitmap(filename)
+    
+    cf = 0x09
+    env = 0x01
+    lcb = @size
+    
+    @record_data =  [cf, env, lcb].pack('v2L') + data
+  end
+  
+  # Convert a 24 bit bitmap into the modified internal format used by Windows.
+  # This is described in BITMAPCOREHEADER and BITMAPCOREINFO structures in the
+  # MSDN library.
+  def process_bitmap(filename)
+    data = nil
+    File.open(filename, "rb") do |f|
+      data = f.read
+    end
+    
+    raise "bitmap #{filename} doesn't contain enough data" if data.length <= 0x36
+    raise "bitmap #{filename} is not valid" unless data[0, 2] === "BM"
+    
+    # Remove bitmap data: ID.
+    data = data[2..-1]
+
+    # Read and remove the bitmap size. This is more reliable than reading
+    # the data size at offset 0x22.
+    size = data[0,4].unpack('L')[0]
+    size -=  0x36   # Subtract size of bitmap header.
+    size +=  0x0C   # Add size of BIFF header.
+
+    data = data[4..-1]
+    # Remove bitmap data: reserved, offset, header length.
+    data = data[12..-1]
+    # Read and remove the bitmap width and height. Verify the sizes.
+    width, height = data[0,8].unpack('L2')
+    data = data[8..-1]
+    raise "bitmap #{filename} largest image width supported is 65k." if (width > 0xFFFF)
+    raise "bitmap #{filename} largest image height supported is 65k." if (height > 0xFFFF)
+    
+    # Read and remove the bitmap planes and bpp data. Verify them.
+    planes, bitcount = data[0,4].unpack('v2')
+    data = data[4..-1]
+    raise "bitmap #{filename} isn't a 24bit true color bitmap." if (bitcount != 24)
+    raise "bitmap #{filename} only 1 plane supported in bitmap image." if (planes != 1)
+
+    # Read and remove the bitmap compression. Verify compression.
+    compression = data[0,4].unpack('L')[0]
+    data = data[4..-1]
+    raise "bitmap #{filename} compression not supported in bitmap image." if (compression != 0)
+        
+    # Remove bitmap data: data size, hres, vres, colours, imp. colours.
+    data = data[20..-1]
+    # Add the BITMAPCOREHEADER data
+    header = [0x000c, width, height, 0x01, 0x18].pack('Lv4')
+    
+    [width, height, size, header + data]
+  end
+end

data/lib/surpass/cell.rb

@@ -0,0 +1,187 @@
+class Cell
+  attr_reader :index
+  
+  def set_style(style)
+    style = StyleFormat.new(style) if style.is_a?(Hash)
+    @format_index = @parent.parent_wb.styles.add(style)
+  end
+  
+  def row
+    @parent
+  end
+  
+  def col
+    @index
+  end
+end
+
+### @export "string-cell"
+class StringCell < Cell
+  def initialize(parent, index, format_index, sst_index)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+    @sst_index = sst_index
+  end
+  
+  def to_biff
+    LabelSSTRecord.new(@parent.index, @index, @format_index, @sst_index).to_biff
+  end
+end
+
+### @export "blank-cell"
+class BlankCell < Cell
+  def initialize(parent, index, format_index)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+  end
+  
+  def to_biff
+    BlankRecord.new(@parent.index, @index, @format_index).to_biff
+  end
+end
+### @end
+
+class NumberCell < Cell
+  def initialize(parent, index, format_index, number)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+    @number = number
+  end
+  
+  def rk_record(rk_encoded)
+    RKRecord.new(@parent.index, @index, @format_index, rk_encoded).to_biff
+  end
+  
+  # TODO test this section to be sure numbers are categorized and packed correctly.
+  def to_biff
+    # 30 bit signed int
+    in_range = (-0x20000000 <= @number) && (@number < 0x20000000)
+    is_int = (@number.to_i == @number)
+    if in_range && is_int
+      rk_encoded = 2 | (@number.to_i << 2)
+      return rk_record(rk_encoded)
+    end
+    
+    # try scaling by 100 then using a 30 bit signed int
+    in_range = (-0x20000000 <= @number * 100) && (@number * 100 < 0x20000000)
+    round_trip = (@number.to_i*100) == @number*100
+    if in_range && round_trip
+      rk_encoded = (3 | (@number.to_i*100 << 2))
+      return rk_record(rk_encoded)
+    end
+    
+    w0, w1, w2, w3 = [@number].pack('E').unpack('v4')
+    
+    is_float_rk = (w0 == 0) && (w1 == 0) && (w2 & 0xFFFC) == w2
+    if is_float_rk
+      rk_encoded = (w3 << 16) | w2
+      return rk_record(rk_encoded)
+    end
+    
+    w0, w1, w2, w3 = [@number * 100].pack('E').unpack('v4')
+
+    is_float_rk_100 = w0 == 0 && w1 == 0 && w2 & 0xFFFC == w2
+    if is_float_rk_100
+      rk_encoded = 1 | (w3 << 16) | w2
+      return rk_record(rk_encoded)
+    end
+
+    # If not an RK value, use a NumberRecord instead.
+    NumberRecord.new(@parent.index, @index, @format_index, @number).to_biff
+  end
+end
+
+class MulNumberCell < Cell
+  def initialize(parent, index, format_index, sst_index)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+    @sst_index = sst_index
+  end
+  
+  def to_biff
+    raise "not implemented"
+  end
+end
+
+class MulBlankCell < Cell
+  def initialize(parent, col1, col2, xf_idx)
+    raise unless col1 < col2
+    @parent = parent
+    @col1 = col1
+    @col2 = col2
+    @xf_idx = xf_idx
+  end
+  
+  def to_biff
+    MulBlankRecord.new(@parent.index, @col1, @col2, @xf_idx).to_biff
+  end
+end
+
+### @export "formula-cell"
+class FormulaCell < Cell
+  def initialize(parent, index, format_index, formula, calc_flags = 0)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+    @formula = formula
+    @calc_flags = calc_flags
+  end
+  
+  def to_biff
+    args = [@parent.index, @index, @format_index, @formula.to_biff, @calc_flags]
+    FormulaRecord.new(*args).to_biff
+  end
+end
+### @end
+
+class BooleanCell < Cell
+  def initialize(parent, index, format_index, number)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+    @number = number
+    @is_error = 0
+  end
+  
+  def to_biff
+    number = @number ? 1 : 0
+    BoolErrRecord.new(@parent.index, @index, @format_index, number, @is_error).to_biff
+  end
+end
+
+class ErrorCell < Cell
+  ERROR_CODES = {
+      0x00 =>  0, # Intersection of two cell ranges is empty
+      0x07 =>  7, # Division by zero
+      0x0F => 15, # Wrong type of operand
+      0x17 => 23, # Illegal or deleted cell reference
+      0x1D => 29, # Wrong function or range name
+      0x24 => 36, # Value range overflow
+      0x2A => 42, # Argument or function not available
+      '#NULL!'  =>  0, # Intersection of two cell ranges is empty
+      '#DIV/0!' =>  7, # Division by zero
+      '#VALUE!' => 36, # Wrong type of operand
+      '#REF!'   => 23, # Illegal or deleted cell reference
+      '#NAME?'  => 29, # Wrong function or range name
+      '#NUM!'   => 36, # Value range overflow
+      '#N/A!'   => 42  # Argument or function not available
+  }
+  
+  def initialize(parent, index, format_index, error_string_or_code)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+    @number = ERROR_CODES[error_string_or_code]
+    @is_error = 1
+    
+    raise "invalid error code #{error_string_or_code}" if @number.nil?
+  end
+  
+  def to_biff
+    BoolErrRecord.new(@parent.index, @index, @format_index, @number, @is_error)
+  end
+end

data/lib/surpass/chart.rb

@@ -0,0 +1,16 @@
+class Chart
+  def initialize
+    raise "not implemented"
+  end
+  
+  
+  # ● OBJ Object description for the chart 
+  # ● BOF Type = chart (➜5.8) 
+  # Chart records 
+  # ● EOF End of the Chart Substream of the chart object (5.37) 
+  def to_biff
+    result = []
+    result << Biff8BOFRecord.new(Biff8BOFRecord::CHART).to_biff
+    result.join
+  end
+end

data/lib/surpass/column.rb

@@ -0,0 +1,40 @@
+class Column
+  attr_accessor :index
+  attr_accessor :width
+  attr_accessor :hidden
+  attr_accessor :level
+  attr_accessor :collapse
+  
+  def initialize(index, parent)
+    is_int = index.is_a?(Integer)
+    in_range = (index >= 0) && (index <= 255)
+    raise "column index #{index} is not valid" unless is_int && in_range
+    
+    @index = index
+    @parent = parent
+    @parent_wb = parent.parent
+    @xf_index = 0x0F
+    
+    @width = 0x0B92
+    @hidden = 0
+    @level = 0
+    @collapse = 0
+  end
+  
+  def to_biff
+    options =  (as_numeric(@hidden) & 0x01) << 0
+    options |= (@level & 0x07) << 8
+    options |= (as_numeric(@collapse) & 0x01) << 12
+    
+    ColInfoRecord.new(@index, @index, @width, @xf_index, options).to_biff
+  end
+  
+  def set_style(style)
+    @xf_index = @parent_wb.add_style(style)
+  end
+  
+  def width_in_pixels
+      # *** Approximation ****
+    (self.width * 0.0272 + 0.446).round
+  end
+end