ru_excel 0.0.6

data/lib/ru_excel/bitmap.rb

@@ -0,0 +1,222 @@
+require File.dirname(__FILE__)+'/biff_records'
+module Excel
+  module BiffRecord
+    def _position_image(sheet, row_start, col_start, x1, y1, width, height)
+=begin
+        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
+        
+=end
+        # Adjust start column for offsets that are greater than the col width
+        while x1 >= sheet.col_width(col_start)
+            x1 -= sheet.col_width(col_start)
+            col_start += 1
+        end
+        # Adjust start row for offsets that are greater than the row height
+        while y1 >= sheet.row_height(row_start)
+            y1 -= sheet.row_height(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 >= sheet.col_width(col_end))
+            width -= sheet.col_width(col_end)
+            col_end += 1
+        end
+        # Subtract the underlying cell heights to find the end cell of the image
+        while (height >= sheet.row_height(row_end))
+            height -= sheet.row_height(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.
+        if ((sheet.col_width( col_start) == 0) || (sheet.col_width( col_end) == 0) ||
+            (sheet.row_height(row_start) == 0) || (sheet.row_height(row_end) == 0))
+            return
+        end
+        # Convert the pixel values to the percentage value expected by Excel
+        x1 = x1.to_f / sheet.col_width( col_start) * 1024
+        y1 = y1.to_f / sheet.row_height(row_start) * 256
+        # Distance to right side of object
+        x2 = width.to_f  / sheet.col_width( col_end) * 1024
+        # Distance to bottom of object
+        y2 = height.to_f / sheet.row_height(row_end) * 256
+        [col_start, x1, row_start, y1, col_end, x2, row_end, y2]
+    end
+
+    def objBmpRecord(row, col, sheet, im_data_bmp, x, y, scale_x, scale_y)
+
+        # Scale the frame of the image.
+        width = im_data_bmp.width * scale_x
+        height = im_data_bmp.height * scale_y
+
+        # Calculate the vertices of the image and write the OBJ record
+        col_start, x1, row_start, y1, col_end, x2, row_end, y2 = _position_image(sheet, row, col, x, y, width, height)
+
+=begin
+            Store the OBJ record that precedes an IMDATA record. This could be generalise
+            to support other Excel objects.
+=end
+        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
+        
+        get_biff_data(0x005D, [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].pack('Vv12VvC8vVv4V'))
+    end
+    
+    def _process_bitmap(bitmap)
+=begin
+        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.
+=end
+        # Open file and binmode the data in case the platform needs it.
+        data = nil
+        fh = File.open(bitmap, "rb") do |fh| data = fh.read() end
+        # Check that the file is big enough to be a bitmap.
+        if data.length <= 0x36
+            raise Exception("bitmap doesn't contain enough data.")
+        end
+        # The first 2 bytes are used to identify the bitmap.
+        if (data[0...(2)] != "BM")
+            raise Exception("bitmap doesn't appear to to be a valid bitmap image.")
+        end
+        # 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("V")[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("VV")
+        data = data[(8)..-1]
+        if (width > 0xFFFF)
+            raise Exception("bitmap=> largest image width supported is 65k.")
+        end
+        if (height > 0xFFFF)
+            raise Exception("bitmap=> largest image height supported is 65k.")
+        end
+        # Read and remove the bitmap planes and bpp data. Verify them.
+        planes, bitcount = data[0...(4)].unpack("vv")
+        data = data[(4)..-1]
+        if (bitcount != 24)
+            raise Exception("bitmap isn't a 24bit true color bitmap.")
+        end
+        if (planes != 1)
+            raise Exception("bitmap=> only 1 plane supported in bitmap image.")
+        end
+        # Read and remove the bitmap compression. Verify compression.
+        compression = data[0...(4)].unpack("V")[0]
+        data = data[(4)..-1]
+        if (compression != 0)
+            raise Exception("bitmap=> compression not supported in bitmap image.")
+        end
+        # 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("Vvvvv")
+        data = header + data
+        [width, height, size, data]
+    end
+    
+    def imDataBmpRecord
+        rec_id  0x007F
+=begin
+            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.
+=end
+        @width, @height, @size, data = _process_bitmap(filename)
+        # Write the IMDATA record to store the bitmap data
+        cf = 0x09
+        env = 0x01
+        lcb = @size
+        get_biff_data(0x007F, [cf, env, lcb, data].pack("vvVa*"))
+    end
+  end
+end

data/lib/ru_excel/cell.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__)+'/biff_records'
+
+module Excel
+  module Cell
+    extend self
+    def strCell(parent, idx, xf_idx, sst_idx)
+        BiffRecord.labelSSTRecord(parent.get_index, idx, xf_idx, sst_idx)
+    end
+    def blankCell(parent, idx, xf_idx)
+        BiffRecord.blankRecord(parent.get_index, idx, xf_idx)
+    end
+    def mulBlankCell(parent, col1, col2, xf_idx)
+        BiffRecord.mulBlankRecord(parent.get_index, col1, col2, xf_idx)
+    end
+    def numberCell(parent, idx, xf_idx, number)
+        rk_encoded = 0
+        packed = [number.to_f].pack('E')
+
+        #print @number
+        w0, w1, w2, w3 = packed.unpack('v4')
+        if w0 == 0 && w1 == 0 && w2 & 0xFFFC == w2
+            # 34 lsb are 0
+            #print "float RK"
+            rk_encoded = (w3 << 16) | w2
+            BiffRecord.rkRecord(parent.get_index, idx, xf_idx, rk_encoded)
+        elsif number.abs < 0x40000000 && number.to_i == number
+            #print "30-bit integer RK"
+            rk_encoded = 2 | (number.to_i << 2)
+            BiffRecord.rkRecord(parent.get_index, idx, xf_idx, rk_encoded)
+        else
+          temp = number*100
+          packed100 = [ temp].pack('E')
+          w0, w1, w2, w3 = packed100.unpack('v4')
+          if w0 == 0 && w1 == 0 && w2 & 0xFFFC == w2
+              # 34 lsb are 0
+              #print "float RK*100"
+              rk_encoded = 1 | (w3 << 16) | w2
+              BiffRecord.rkRecord(parent.get_index, idx, xf_idx, rk_encoded)
+          elsif temp.abs < 0x40000000 && temp.to_i == temp
+              #print "30-bit integer RK*100"
+              rk_encoded = 3 | (temp.to_i << 2)
+              BiffRecord.rkRecord(parent.get_index, idx, xf_idx, rk_encoded)
+          else
+          #print "Number" 
+          #print
+              BiffRecord.numberRecord(parent.get_index, idx, xf_idx, number)
+          end
+        end
+    end
+    def mulNumberCell(parent, idx, xf_idx, sst_idx)
+        raise Exception
+    end
+    def fomulaCell(parent, idx, xf_idx, frmla)
+        BiffRecords.formulaRecord(parent.get_index, idx, xf_idx, frmla.rpn())
+    end
+  end
+end

data/lib/ru_excel/column.rb

@@ -0,0 +1,31 @@
+dir = File.dirname(__FILE__)
+require dir+'/biff_records'
+require dir+'/deco'
+
+module Excel
+  class Column
+    def initialize(indx, parent_sheet)
+        @index = indx
+        @parent = parent_sheet
+        @parent_wb = parent_sheet.parent
+        @xf_index = 0x0F
+        
+        @width = 0x0B92
+        @hidden = 0
+        @level = 0
+        @collapse = 0
+    end
+    attr_accessor :level, :hidden, :width, :collapse
+
+
+    def get_biff_record
+        options =  (@hidden & 0x01) << 0
+        options |= (@level & 0x07) << 8
+        options |= (@collapse & 0x01) << 12
+        
+        BiffRecord.colInfoRecord(@index, @index, @width, @xf_index, options)
+    end
+  end
+end        
+        
+        

data/lib/ru_excel/compound_doc.rb

@@ -0,0 +1,268 @@
+# This implementation writes only 'Root Entry', 'Workbook' streams
+# and 2 empty streams for aligning directory stream on sector boundary
+# 
+# LAYOUT
+# 0         header
+# 76                MSAT (1st part=> 109 SID)
+# 512       workbook stream
+# ...       additional MSAT sectors if streams' size > about 7 Mb == (109*512 * 128)
+# ...       SAT
+# ...       directory stream
+#
+# NOTE=> this layout is "ad hoc". It can be more general. RTFM
+module Excel
+  class XlsDoc
+    SECTOR_SIZE = 0x0200
+    MIN_LIMIT   = 0x1000
+
+    SID_FREE_SECTOR  = -1
+    SID_END_OF_CHAIN = -2
+    SID_USED_BY_SAT  = -3
+    SID_USED_BY_MSAT = -4
+
+    def initialize
+        #@book_stream = ''                # padded
+        @book_stream_sect = []
+
+        @dir_stream = ''
+        @dir_stream_sect = []
+
+        @packed_SAT = ''
+        @SAT_sect = []
+
+        @packed_MSAT_1st = ''
+        @packed_MSAT_2nd = ''
+        @MSAT_sect_2nd = []
+
+        @header = ''
+    end
+    def self.__block(dentry_name, dentry_type, dentry_colour, dentry_did_left,
+                     dentry_did_right, dentry_did_root, dentry_start_sid, dentry_stream_sz)
+        [
+           dentry_name,
+           dentry_name.length,
+           dentry_type,
+           dentry_colour,
+           dentry_did_left, 
+           dentry_did_right,
+           dentry_did_root,
+           0, 0, 0, 0, 0, 0, 0, 0, 0,
+           dentry_start_sid,
+           dentry_stream_sz,
+           0
+        ].pack('a64 v C2 l3 L9 l L L')
+    end
+    STREAM_START = __block(
+	"Root Entry\x00".gsub!(/(.)/,"\\1\x00"),
+        0x05, # root storage
+        0x01, # black
+        -1,
+        -1,
+        1,
+        -2,
+        0)
+    STREAM_WORKBOOK_DENTRY_NAME = "Workbook\x00".gsub!(/(.)/,"\\1\x00")
+    STREAM_PADDING = __block(
+        '',
+        0x00, # empty
+        0x01, # black
+        -1,
+        -1,
+        -1,
+        -2,
+        0) * 2
+    def _build_directory # align on sector boundary
+        @dir_stream = ''
+        @dir_stream << STREAM_START
+        @dir_stream << XlsDoc.__block(
+            STREAM_WORKBOOK_DENTRY_NAME,
+            0x02, # user stream
+            0x01, # black
+            -1,
+            -1,
+            -1,
+            0,
+            @book_stream_len)
+
+        @dir_stream << STREAM_PADDING
+    end
+
+    def _build_sat
+        # Build SAT
+        book_sect_count = @book_stream_len >> 9
+        dir_sect_count  = @dir_stream.length >> 9
+        
+        total_sect_count     = book_sect_count + dir_sect_count
+        _SAT_sect_count       = 0
+        _MSAT_sect_count      = 0
+        _SAT_sect_count_limit = 109
+        while total_sect_count > 128*_SAT_sect_count or _SAT_sect_count > _SAT_sect_count_limit
+            _SAT_sect_count  += 1
+            total_sect_count += 1
+            if _SAT_sect_count > _SAT_sect_count_limit
+                _MSAT_sect_count      += 1
+                total_sect_count     += 1
+                _SAT_sect_count_limit += 127
+            end
+        end
+
+
+        _SAT = [SID_FREE_SECTOR]*128*_SAT_sect_count
+
+        sect = 0
+        while sect < book_sect_count - 1
+            @book_stream_sect << sect
+            _SAT[sect] = sect + 1
+            sect += 1
+        end
+        @book_stream_sect << sect
+        _SAT[sect] = SID_END_OF_CHAIN
+        sect += 1
+
+        while sect < book_sect_count + _MSAT_sect_count
+            @MSAT_sect_2nd << sect
+            _SAT[sect] = SID_USED_BY_MSAT
+            sect += 1
+        end
+
+        while sect < book_sect_count + _MSAT_sect_count + _SAT_sect_count
+            @SAT_sect << sect
+            _SAT[sect] = SID_USED_BY_SAT
+            sect += 1
+        end
+
+        while sect < book_sect_count + _MSAT_sect_count + _SAT_sect_count + dir_sect_count - 1
+            @dir_stream_sect << sect
+            _SAT[sect] = sect + 1
+            sect += 1
+        end
+        @dir_stream_sect << sect
+        _SAT[sect] = SID_END_OF_CHAIN
+        sect += 1
+
+        @packed_SAT = _SAT.pack('l%d'%(_SAT_sect_count*128))
+
+	
+        _MSAT_1st = @SAT_sect + [SID_FREE_SECTOR]*([109-@SAT_sect.length,0].max)
+
+        @packed_MSAT_1st = _MSAT_1st.pack('l109')
+
+        _MSAT_2nd = [SID_FREE_SECTOR]*128*_MSAT_sect_count
+        if _MSAT_sect_count > 0
+            _MSAT_2nd[- 1] = SID_END_OF_CHAIN
+        end
+
+        i = 109
+        msat_sect = 0
+        sid_num = 0
+        while i < _SAT_sect_count
+            if (sid_num + 1) % 128 == 0
+                #print 'link: ',
+                msat_sect += 1
+                if msat_sect < @MSAT_sect_2nd.length
+                    _MSAT_2nd[sid_num] = @MSAT_sect_2nd[msat_sect]
+                end
+            else
+                #print 'sid: ',
+                _MSAT_2nd[sid_num] = @SAT_sect[i]
+                i += 1
+            end
+            #print sid_num, MSAT_2nd[sid_num]
+            sid_num += 1
+        end
+
+        @packed_MSAT_2nd = _MSAT_2nd.pack('l%d'%(_MSAT_sect_count*128))
+
+        #print vars()
+        #print zip(range(0, sect), SAT)
+        #print @book_stream_sect
+        #print self.MSAT_sect_2nd
+        #print MSAT_2nd
+        #print self.SAT_sect
+        #print @dir_stream_sect
+    end
+
+    def _build_header
+        doc_magic             = "\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1"
+        file_uid              = "\x00"*16
+        rev_num               = "\x3E\x00"
+        ver_num               = "\x03\x00"
+        byte_order            = "\xFE\xFF"
+        log_sect_size         = [ 9].pack('v')
+        log_short_sect_size   = [ 6].pack('v')
+        not_used0             = "\x00"*10
+        total_sat_sectors     = [@SAT_sect.length].pack('V')
+        dir_start_sid         = [ @dir_stream_sect[0]].pack('V')
+        not_used1             = "\x00"*4
+        min_stream_size       = [ 0x1000].pack('V')
+        ssat_start_sid        = [ -2].pack('V')
+        total_ssat_sectors    = [ 0].pack('V')
+
+        if @MSAT_sect_2nd.length == 0
+            msat_start_sid        = [ -2].pack('V')
+        else
+            msat_start_sid        = [@MSAT_sect_2nd[0]].pack('V')
+        end
+
+        total_msat_sectors    = [@MSAT_sect_2nd.length].pack('V')
+
+        @header =                    [  doc_magic,
+                                        file_uid,
+                                        rev_num,
+                                        ver_num,
+                                        byte_order,
+                                        log_sect_size,
+                                        log_short_sect_size,
+                                        not_used0,
+                                        total_sat_sectors,
+                                        dir_start_sid,
+                                        not_used1,
+                                        min_stream_size,
+                                        ssat_start_sid,
+                                        total_ssat_sectors,
+                                        msat_start_sid,
+                                        total_msat_sectors
+                                    ].join('')
+    end
+
+    def save(f, stream)
+        # 1. Align stream on 0x1000 boundary (and therefore on sector boundary)
+	is_string = f.is_a? String
+	f = File.new(f, 'wb') if is_string
+        padding = "\x00" * (0x1000 - (stream.length % 0x1000))
+        @book_stream_len = stream.length + padding.length
+
+        _build_directory()
+        _build_sat()
+        _build_header()
+        
+        f.write(@header)
+        f.write(@packed_MSAT_1st)
+        f.write(stream)
+        f.write(padding)
+        f.write(@packed_MSAT_2nd)
+        f.write(@packed_SAT)
+        f.write(@dir_stream)
+	f.close if is_string
+    end
+
+    def binary(stream)
+        padding = "\x00" * (0x1000 - (stream.length % 0x1000))
+        @book_stream_len = stream.length + padding.length
+
+        _build_directory()
+        _build_sat()
+        _build_header()
+        "#@header#@packed_MSAT_1st#{stream}#{padding}#@packed_MSAT_2nd#@packed_SAT#@dir_stream"
+    end
+  end
+end
+
+if $0 == __FILE__
+    d = XlsDoc()
+    d.save('a.aaa', 'b'*17000)
+end
+
+
+
+