ricardoo27-writeexcel 0.6.12.1

data/lib/writeexcel/helper.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+#
+# helper.rb
+#
+  # Convert to US_ASCII encoding if ascii characters only.
+  def convert_to_ascii_if_ascii(str)
+    return nil if str.nil?
+    ruby_18 do
+      unless str =~ /[^!"#\$%&'\(\)\*\+,\-\.\/\:\;<=>\?@0-9A-Za-z_\[\\\]\{\}^` ~\0\n]/
+        str = String.new(str)
+      end
+    end ||
+    ruby_19 do
+      if str.ascii_only?
+        str = [str].pack('a*')
+      end
+    end
+    str
+  end
+  private :convert_to_ascii_if_ascii
+
+  def utf16be_to_16le(utf16be)
+    utf16be.unpack('n*').pack('v*')
+  end
+
+  def utf8_to_16be(utf8)
+    ruby_18 { NKF.nkf('-w16B0 -m0 -W', utf8) } ||
+    ruby_19 do
+      utf16be = NKF.nkf('-w16B0 -m0 -W', utf8)
+      utf16be.force_encoding('UTF-16BE')
+    end
+  end
+  private :utf8_to_16be
+
+  def utf8_to_16le(utf8)
+    ruby_18 { NKF.nkf('-w16L0 -m0 -W', utf8) } ||
+    ruby_19 do
+      utf16le = NKF.nkf('-w16L0 -m0 -W', utf8)
+      utf16le.force_encoding('UTF-16LE')
+    end
+  end
+  private :utf8_to_16le
+
+  def ascii_to_16be(ascii)
+    ascii.unpack("C*").pack("n*")
+    ruby_19 { ascii.force_encoding('UTF-16BE') }
+    ascii
+  end
+  private :ascii_to_16be
+
+  def store_simple(record, length, *args)
+    header = [record, length].pack('vv')
+    data = args.collect { |arg| [arg].pack('v') }.join('')
+
+    append(header, data)
+  end
+  private :store_simple
+
+  # Convert base26 column string to a number.
+  # All your Base are belong to us.
+  def chars_to_col(chars)
+    expn = 0
+    col  = 0
+    while (!chars.empty?)
+      char = chars.pop   # LS char first
+      col  += (char.ord - "A".ord + 1) * (26 ** expn)
+      expn += 1
+    end
+    col
+  end
+  private :chars_to_col
+
+  NonAscii = /[^!"#\$%&'\(\)\*\+,\-\.\/\:\;<=>\?@0-9A-Za-z_\[\\\]\{\}^` ~\0\n]/
+
+  def is_utf8?(str)
+    ruby_18 { str =~ NonAscii } ||
+    ruby_19 { str.encoding == Encoding::UTF_8 }
+  end

data/lib/writeexcel/image.rb

@@ -0,0 +1,218 @@
+# -*- coding:utf-8 -*-
+require 'digest/md5'
+
+module Writeexcel
+  class Image
+    attr_reader :row, :col, :filename, :x_offset, :y_offset, :scale_x, :scale_y
+    attr_reader :data, :size, :checksum1, :checksum2
+    attr_accessor :id, :type, :width, :height, :ref_count
+
+    def initialize(worksheet, row, col, filename, x_offset = 0, y_offset = 0, scale_x = 1, scale_y = 1)
+      @worksheet = worksheet
+      @row = row
+      @col = col
+      @filename = filename
+      @x_offset = x_offset
+      @y_offset = y_offset
+      @scale_x  = scale_x
+      @scale_y  = scale_y
+      get_checksum_method
+    end
+
+    def import
+      File.open(@filename, "rb") do |fh|
+        raise "Couldn't import #{@filename}: #{$!}" unless fh
+        @data = fh.read
+      end
+      @size = data.bytesize
+      @checksum1 = image_checksum(@data)
+      @checksum2 = @checksum1
+      process
+    end
+
+    def store_image_record(i, num_images, num_charts, num_filters, num_comments, spid)
+      image_width  = width
+      image_height = height
+
+      image_width  = width  * scale_x unless scale_x == 0
+      image_height = height * scale_y unless scale_y == 0
+
+      # Calculate the positions of image object.
+      vertices = @worksheet.position_object(col, row, x_offset, y_offset, image_width, image_height)
+
+      if (i == 0)
+        data = images_parent_msodrawing_record(num_images, num_charts, num_filters, num_comments, spid, id, vertices)
+      else
+        data = images_child_msodrawing_record(spid, id, vertices)
+      end
+      record = 0x00EC           # Record identifier
+      length = 0x0000           # Bytes to follow
+
+      length = data.bytesize
+      header = [record, length].pack("vv")
+
+      append(header, data)
+    end
+
+    private
+
+    # Process the image and extract dimensions.
+    def process
+      case filetype
+      when 'PNG'
+        process_png(@data)
+      when 'JPG'
+        process_jpg(@data)
+      when 'BMP'
+        process_bmp(@data)
+        # The 14 byte header of the BMP is stripped off.
+        @data[0, 13] = ''
+        # A checksum of the new image data is also required.
+        @checksum2  = image_checksum(@data, @id, @id)
+        # Adjust size -14 (header) + 16 (extra checksum).
+        @size += 2
+      end
+    end
+
+    def filetype
+      return 'PNG' if @data.unpack('x A3')[0] ==  'PNG'
+      return 'BMP' if @data.unpack('A2')[0] == 'BM'
+      if data.unpack('n')[0] == 0xFFD8
+        return 'JPG' if @data.unpack('x6 A4')[0] == 'JFIF' || @data.unpack('x6 A4')[0] == 'Exif'
+      else
+        raise "Unsupported image format for file: #{@filename}\n"
+      end
+    end
+
+    # Extract width and height information from a PNG file.
+    def process_png(data)
+      @type   = 6 # Excel Blip type (MSOBLIPTYPE).
+      @width  = data[16, 4].unpack("N")[0]
+      @height = data[20, 4].unpack("N")[0]
+    end
+
+    # Extract width and height information from a BMP file.
+    def process_bmp(data)       #:nodoc:
+      @type     = 7   # Excel Blip type (MSOBLIPTYPE).
+      # Read the bitmap width and height. Verify the sizes.
+      @width, @height = data.unpack("x18 V2")
+      check_verify(data)
+    end
+
+    def check_verify(data)
+      # Check that the file is big enough to be a bitmap.
+      raise "#{@filename} doesn't contain enough data." if data.bytesize <= 0x36
+      raise "#{@filename}: largest image width #{width} supported is 65k." if @width > 0xFFFF
+      raise "#{@filename}: largest image height supported is 65k." if @height > 0xFFFF
+
+      # Read the bitmap planes and bpp data. Verify them.
+      planes, bitcount = data.unpack("x26 v2")
+      raise "#{@filename} isn't a 24bit true color bitmap." unless bitcount == 24
+      raise "#{@filename}: only 1 plane supported in bitmap image." unless planes == 1
+
+      # Read the bitmap compression. Verify compression.
+      compression = data.unpack("x30 V")
+      raise "#{@filename}: compression not supported in bitmap image." unless compression == 0
+    end
+
+    # Extract width and height information from a JPEG file.
+    def process_jpg(data)
+      @type     = 5  # Excel Blip type (MSOBLIPTYPE).
+
+      offset = 2
+      data_length = data.bytesize
+
+      # Search through the image data to find the 0xFFC0 marker. The height and
+      # width are contained in the data for that sub element.
+      while offset < data_length
+        marker  = data[offset,   2].unpack("n")
+        marker = marker[0]
+        length  = data[offset+2, 2].unpack("n")
+        length = length[0]
+
+        if marker == 0xFFC0 || marker == 0xFFC2
+          height = data[offset+5, 2].unpack("n")
+          @height = height[0]
+          width  = data[offset+7, 2].unpack("n")
+          @width  = width[0]
+          break
+        end
+
+        offset += length + 2
+        break if marker == 0xFFDA
+      end
+
+      raise "#{@filename}: no size data found in jpeg image.\n" unless @height
+    end
+
+    #
+    # Generate a checksum for the image using whichever module is available. The
+    # available modules are checked in get_checksum_method(). Excel uses an MD4
+    # checksum but any other will do. In the event of no checksum module being
+    # available we simulate a checksum using the image index.
+    #
+    # index1 and index2 is not used.
+    #
+    def image_checksum(data, index1 = 0, index2 = 0)       #:nodoc:
+      case @checksum_method
+      when 3
+        Digest::MD5.hexdigest(data)
+      when 1
+        # Digest::MD4
+        #           return Digest::MD4::md4_hex($data);
+      when 2
+        # Digest::Perl::MD4
+        #           return Digest::Perl::MD4::md4_hex($data);
+      else
+        # Default
+  #      return sprintf('%016X%016X', index2, index1)
+      end
+    end
+
+    #
+    # Check for modules available to calculate image checksum. Excel uses MD4 but
+    # MD5 will also work.
+    #
+    # ------- cxn03651 add -------
+    # md5 can use in ruby. so, @checksum_method is always 3.
+
+    def get_checksum_method       #:nodoc:
+      @checksum_method = 3
+    end
+
+    def images_parent_msodrawing_record(num_images, charts_size, num_filters, num_comments, spid, image_id, vertices)
+      dg_length   =  156 + 84*(num_images - 1)
+      spgr_length =  132 + 84*(num_images - 1)
+
+      dg_length   += 120 * charts_size
+      spgr_length += 120 * charts_size
+
+      dg_length   += 96 * num_filters
+      spgr_length += 96 * num_filters
+
+      dg_length   += 128 * num_comments
+      spgr_length += 128 * num_comments
+
+      data = @worksheet.store_parent_mso_record(dg_length, spgr_length, spid)
+      spid += 1
+      data += @worksheet.store_mso_sp_container(76)
+      data += @worksheet.store_mso_sp(75, spid, 0x0A00)
+      spid += 1
+      data += @worksheet.store_mso_opt_image(image_id)
+      data += @worksheet.store_mso_client_anchor(2, *vertices)
+      data += @worksheet.store_mso_client_data
+    end
+
+    def images_child_msodrawing_record(spid, image_id, vertices)
+      data = @worksheet.store_mso_sp_container(76) + @worksheet.store_mso_sp(75, spid, 0x0A00)
+      spid = spid + 1
+      data += @worksheet.store_mso_opt_image(image_id)    +
+        @worksheet.store_mso_client_anchor(2, *vertices)  +
+        @worksheet.store_mso_client_data
+    end
+
+    def append(*args)
+      @worksheet.append(*args)
+    end
+  end
+end

data/lib/writeexcel/olewriter.rb

@@ -0,0 +1,305 @@
+# -*- coding: utf-8 -*-
+###############################################################################
+#
+# BIFFwriter - An abstract base class for Excel workbooks and worksheets.
+#
+#
+# Used in conjunction with WriteExcel
+#
+# Copyright 2000-2010, John McNamara, jmcnamara@cpan.org
+#
+# original written in Perl by John McNamara
+# converted to Ruby by Hideo Nakamura, cxn03651@msj.biglobe.ne.jp
+#
+class MaxSizeError < StandardError; end       #:nodoc:
+
+class OLEWriter       #:nodoc:
+
+  # Not meant for public consumption
+  MaxSize    = 7087104 # Use WriteExcel::Big to exceed this
+  BlockSize  = 4096
+  BlockDiv   = 512
+  ListBlocks = 127
+
+  attr_reader :biff_size, :book_size, :big_blocks, :list_blocks
+  attr_reader :root_start, :size_allowed
+  attr_accessor :biff_only, :internal_fh
+
+  # Accept an IO or IO-like object or a filename (as a String)
+  def initialize(arg)
+    if arg.respond_to?(:to_str)
+      @io = File.open(arg, "w")
+    else
+      @io = arg
+    end
+    @io.binmode if @io.respond_to?(:binmode)
+
+    @filehandle    = ""
+    @fileclosed    = false
+    @internal_fh   = 0
+    @biff_only     = 0
+    @size_allowed  = true
+    @biff_size     = 0
+    @book_size     = 0
+    @big_blocks    = 0
+    @list_blocks   = 0
+    @root_start    = 0
+    @block_count   = 4
+  end
+
+  # Imitate IO.open behavior
+
+  ###############################################################################
+  #
+  # _initialize()
+  #
+  # Create a new filehandle or use the provided filehandle.
+  #
+  def _initialize
+    olefile = @olefilename
+
+    # If the filename is a reference it is assumed that it is a valid
+    # filehandle, if not we create a filehandle.
+    #
+
+    # Create a new file, open for writing
+    fh = open(olefile, "wb")
+
+    # Workbook.pm also checks this but something may have happened since
+    # then.
+    raise "Can't open olefile. It may be in use or protected.\n" unless fh
+
+    @internal_fh = 1
+
+    # Store filehandle
+    @filehandle = fh
+  end
+
+  def self.open(arg)
+    if block_given?
+      ole = self.new(arg)
+      result = yield(ole)
+      ole.close
+      result
+    else
+      self.new(arg)
+    end
+  end
+
+  ###############################################################################
+  #
+  # write($data)
+  #
+  # Write BIFF data to OLE file.
+  #
+  def write(data)
+    @io.write(data)
+  end
+
+  ###############################################################################
+  #
+  # set_size(biffsize)
+  #
+  # Set the size of the data to be written to the OLE stream
+  #
+  #   $big_blocks = (109 depot block x (128 -1 marker word)
+  #                 - (1 x end words)) = 13842
+  #   $maxsize    = $big_blocks * 512 bytes = 7087104
+  #
+  def set_size(size = BlockSize)
+    if size > MaxSize
+      return @size_allowed = false
+    end
+
+    @biff_size = size
+    @book_size = [size, BlockSize].max
+    @size_allowed = true
+  end
+
+  ###############################################################################
+  #
+  # _calculate_sizes()
+  #
+  # Calculate various sizes needed for the OLE stream
+  #
+  def calculate_sizes
+    @big_blocks  = (@book_size.to_f/BlockDiv.to_f).ceil
+    @list_blocks = (@big_blocks / ListBlocks) + 1
+    @root_start  = @big_blocks
+  end
+
+  ###############################################################################
+  #
+  # close()
+  #
+  # Write root entry, big block list and close the filehandle.
+  # This routine is used to explicitly close the open filehandle without
+  # having to wait for DESTROY.
+  #
+  def close
+    if @size_allowed == true
+      write_padding          if @biff_only == 0
+      write_property_storage if @biff_only == 0
+      write_big_block_depot  if @biff_only == 0
+    end
+    @io.close
+  end
+
+  ###############################################################################
+  #
+  # write_header()
+  #
+  # Write OLE header block.
+  #
+  def write_header
+    return if @biff_only == 1
+    calculate_sizes
+    root_start = @root_start
+    num_lists  = @list_blocks
+
+    id              = [0xD0CF11E0, 0xA1B11AE1].pack("NN")
+    unknown1        = [0x00, 0x00, 0x00, 0x00].pack("VVVV")
+    unknown2        = [0x3E, 0x03].pack("vv")
+    unknown3        = [-2].pack("v")
+    unknown4        = [0x09].pack("v")
+    unknown5        = [0x06, 0x00, 0x00].pack("VVV")
+    num_bbd_blocks  = [num_lists].pack("V")
+    root_startblock = [root_start].pack("V")
+    unknown6        = [0x00, 0x1000].pack("VV")
+    sbd_startblock  = [-2].pack("V")
+    unknown7        = [0x00, -2 ,0x00].pack("VVV")
+
+    write(id)
+    write(unknown1)
+    write(unknown2)
+    write(unknown3)
+    write(unknown4)
+    write(unknown5)
+    write(num_bbd_blocks)
+    write(root_startblock)
+    write(unknown6)
+    write(sbd_startblock)
+    write(unknown7)
+
+    unused = [-1].pack("V")
+
+    1.upto(num_lists){
+      root_start += 1
+      write([root_start].pack("V"))
+    }
+
+    num_lists.upto(108){
+      write(unused)
+    }
+  end
+
+  ###############################################################################
+  #
+  # _write_big_block_depot()
+  #
+  # Write big block depot.
+  #
+  def write_big_block_depot
+    num_blocks   = @big_blocks
+    num_lists    = @list_blocks
+    total_blocks = num_lists * 128
+    used_blocks  = num_blocks + num_lists + 2
+
+    marker          = [-3].pack("V")
+    end_of_chain    = [-2].pack("V")
+    unused          = [-1].pack("V")
+
+    1.upto(num_blocks-1){|n|
+      write([n].pack("V"))
+    }
+
+    write end_of_chain
+    write end_of_chain
+
+    1.upto(num_lists){ write(marker) }
+
+    used_blocks.upto(total_blocks){ write(unused) }
+
+  end
+
+  ###############################################################################
+  #
+  # _write_property_storage()
+  #
+  # Write property storage. TODO: add summary sheets
+  #
+  def write_property_storage
+
+    #########  name         type  dir start size
+    write_pps('Root Entry', 0x05,  1,   -2, 0x00)
+    write_pps('Workbook',   0x02, -1, 0x00, @book_size)
+    write_pps("",           0x00, -1, 0x00, 0x0000)
+    write_pps("",           0x00, -1, 0x00, 0x0000)
+  end
+
+  ###############################################################################
+  #
+  # _write_pps()
+  #
+  # Write property sheet in property storage
+  #
+  def write_pps(name, type, dir, start, size)
+    length = 0
+    ord_name = []
+    unless name.empty?
+      name = name + "\0"
+      ord_name = name.unpack("c*")
+      length = name.bytesize * 2
+    end
+
+    rawname        = ord_name.pack("v*")
+    zero           = [0].pack("C")
+
+    pps_sizeofname = [length].pack("v")   #0x40
+    pps_type       = [type].pack("v")     #0x42
+    pps_prev       = [-1].pack("V")       #0x44
+    pps_next       = [-1].pack("V")       #0x48
+    pps_dir        = [dir].pack("V")      #0x4c
+
+    unknown = [0].pack("V")
+
+    pps_ts1s       = [0].pack("V")        #0x64
+    pps_ts1d       = [0].pack("V")        #0x68
+    pps_ts2s       = [0].pack("V")        #0x6c
+    pps_ts2d       = [0].pack("V")        #0x70
+    pps_sb         = [start].pack("V")    #0x74
+    pps_size       = [size].pack("V")     #0x78
+
+    write(rawname)
+    write(zero * (64 - length)) if 64 - length >= 1
+    write(pps_sizeofname)
+    write(pps_type)
+    write(pps_prev)
+    write(pps_next)
+    write(pps_dir)
+    write(unknown * 5)
+    write(pps_ts1s)
+    write(pps_ts1d)
+    write(pps_ts2s)
+    write(pps_ts2d)
+    write(pps_sb)
+    write(pps_size)
+    write(unknown)
+  end
+
+  ###############################################################################
+  #
+  # _write_padding()
+  #
+  # Pad the end of the file
+  #
+  def write_padding
+    min_size = 512
+    min_size = BlockSize if @biff_size < BlockSize
+
+    if @biff_size % min_size != 0
+      padding = min_size - (@biff_size % min_size)
+      write("\0" * padding)
+    end
+  end
+end