ricardoo27-writeexcel 0.6.12.1

data/lib/writeexcel/charts/stock.rb

@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*-
+###############################################################################
+#
+# Stock - A writer class for Excel Stock charts.
+#
+# Used in conjunction with WriteExcel::Chart.
+#
+# See formatting note in WriteExcel::Chart.
+#
+# 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
+#
+
+require 'writeexcel'
+
+module Writeexcel
+
+class Chart
+
+  # ==SYNOPSIS
+  #
+  # To create a simple Excel file with a Stock chart using WriteExcel:
+  #
+  #     #!/usr/bin/ruby -w
+  #
+  #     require 'writeexcel'
+  #
+  #     workbook  = WriteExcel.new('chart.xls')
+  #     worksheet = workbook.add_worksheet
+  #
+  #     chart     = workbook.add_chart(:type => 'Chart::Stock')
+  #
+  #     # Add a series for each Open-High-Low-Close.
+  #     chart.add_series(:categories => '=Sheet1!$A$2:$A$6', :values => '=Sheet1!$B$2:$B$6')
+  #     chart.add_series(:categories => '=Sheet1!$A$2:$A$6', :values => '=Sheet1!$C$2:$C$6')
+  #     chart.add_series(:categories => '=Sheet1!$A$2:$A$6', :values => '=Sheet1!$D$2:$D$6')
+  #     chart.add_series(:categories => '=Sheet1!$A$2:$A$6', :values => '=Sheet1!$E$2:$E$6')
+  #
+  #     # Add the worksheet data the chart refers to.
+  #     # ... See the full example below.
+  #
+  #     workbook.close
+  #
+  # ==DESCRIPTION
+  #
+  # This module implements Stock charts for WriteExcel. The chart object
+  # is created via the Workbook add_chart() method:
+  #
+  #     chart = workbook.add_chart(:type => 'Chart::Stock')
+  #
+  # Once the object is created it can be configured via the following methods
+  # that are common to all chart classes:
+  #
+  #     chart.add_series
+  #     chart.set_x_axis
+  #     chart.set_y_axis
+  #     chart.set_title
+  #
+  # These methods are explained in detail in Chart section of WriteExcel.
+  # Class specific methods or settings, if any, are explained below.
+  #
+  # ==Stock Chart Methods
+  #
+  # There aren't currently any stock chart specific methods.
+  # See the TODO section of Chart section in WriteExcel.
+  #
+  # The default Stock chart is an Open-High-Low-Close chart.
+  # A series must be added for each of these data sources.
+  #
+  # The default Stock chart is in black and white. User defined colours
+  # will be added at a later stage.
+  #
+  # ==EXAMPLE
+  #
+  # Here is a complete example that demonstrates most of the available features
+  # when creating a Stock chart.
+  #
+  #     #!/usr/bin/ruby -w
+  #
+  #     require 'writeexcel'
+  #
+  #     workbook    = WriteExcel.new('chart_stock_ex.xls')
+  #     worksheet   = workbook.add_worksheet
+  #     bold        = workbook.add_format(:bold => 1)
+  #     date_format = workbook.add_format(:num_format => 'dd/mm/yyyy')
+  #
+  #     # Add the worksheet data that the charts will refer to.
+  #     headings = [ 'Date', 'Open', 'High', 'Low', 'Close' ]
+  #     data = [
+  #         [ '2009-08-23', 110.75, 113.48, 109.05, 109.40 ],
+  #         [ '2009-08-24', 111.24, 111.60, 103.57, 104.87 ],
+  #         [ '2009-08-25', 104.96, 108.00, 103.88, 106.00 ],
+  #         [ '2009-08-26', 104.95, 107.95, 104.66, 107.91 ],
+  #         [ '2009-08-27', 108.10, 108.62, 105.69, 106.15 ]
+  #    ]
+  #
+  #     worksheet.write('A1', headings, bold)
+  #
+  #     row = 1
+  #     data.each do |d|
+  #         worksheet.write(row, 0, d[0], date_format)
+  #         worksheet.write(row, 1, d[1])
+  #         worksheet.write(row, 2, d[2])
+  #         worksheet.write(row, 3, d[3])
+  #         worksheet.write(row, 4, d[4])
+  #         row += 1
+  #     end
+  #
+  #     # Create a new chart object. In this case an embedded chart.
+  #     chart = workbook.add_chart(:type => 'Chart::Stock', ::embedded => 1)
+  #
+  #     # Add a series for each of the Open-High-Low-Close columns.
+  #     chart.add_series(
+  #       :categories => '=Sheet1!$A$2:$A$6',
+  #       :values     => '=Sheet1!$B$2:$B$6',
+  #       :name       => 'Open'
+  #    )
+  #
+  #     chart.add_series(
+  #       :categories => '=Sheet1!$A$2:$A$6',
+  #       :values     => '=Sheet1!$C$2:$C$6',
+  #       :name       => 'High'
+  #    )
+  #
+  #     chart.add_series(
+  #       :categories => '=Sheet1!$A$2:$A$6',
+  #       :values     => '=Sheet1!$D$2:$D$6',
+  #       :name       => 'Low'
+  #    )
+  #
+  #     chart.add_series(
+  #       :categories => '=Sheet1!$A$2:$A$6',
+  #       :values     => '=Sheet1!$E$2:$E$6',
+  #       :name       => 'Close'
+  #    )
+  #
+  #     # Add a chart title and some axis labels.
+  #     chart.set_title(:name => 'Open-High-Low-Close')
+  #     chart.set_x_axis(:name => 'Date')
+  #     chart.set_y_axis(:name => 'Share price')
+  #
+  #     # Insert the chart into the worksheet (with an offset).
+  #     worksheet.insert_chart('F2', chart, 25, 10)
+  #
+  #     workbook.close
+  #
+  class Stock < Chart
+    ###############################################################################
+    #
+    # new()
+    #
+    #
+    def initialize(*args)   # :nodoc:
+      super
+    end
+
+    ###############################################################################
+    #
+    # _store_chart_type()
+    #
+    # Implementation of the abstract method from the specific chart class.
+    #
+    # Write the LINE chart BIFF record. A stock chart uses the same LINE record
+    # as a line chart but with additional DROPBAR and CHARTLINE records to define
+    # the stock style.
+    #
+    def store_chart_type   # :nodoc:
+      record = 0x1018     # Record identifier.
+      length = 0x0002     # Number of bytes to follow.
+      grbit  = 0x0000     # Option flags.
+
+      store_simple(record, length, grbit)
+    end
+
+    ###############################################################################
+    #
+    # _store_marker_dataformat_stream(). Overridden.
+    #
+    # This is an implementation of the parent abstract method to define
+    # properties of markers, linetypes, pie formats and other.
+    #
+    def store_marker_dataformat_stream   # :nodoc:
+      store_dropbar
+      store_begin
+      store_lineformat(0x00000000, 0x0000, 0xFFFF, 0x0001, 0x004F)
+      store_areaformat(0x00FFFFFF, 0x0000, 0x01, 0x01, 0x09, 0x08)
+      store_end
+
+      store_dropbar
+      store_begin
+      store_lineformat(0x00000000, 0x0000, 0xFFFF, 0x0001, 0x004F)
+      store_areaformat(0x0000, 0x00FFFFFF, 0x01, 0x01, 0x08, 0x09)
+      store_end
+
+      store_chartline
+      store_lineformat(0x00000000, 0x0000, 0xFFFF, 0x0000, 0x004F)
+
+
+      store_dataformat(0x0000, 0xFFFD, 0x0000)
+      store_begin
+      store_3dbarshape
+      store_lineformat(0x00000000, 0x0005, 0xFFFF, 0x0000, 0x004F)
+      store_areaformat(0x00000000, 0x0000, 0x00, 0x01, 0x4D, 0x4D)
+      store_pieformat
+      store_markerformat(0x00, 0x00, 0x00, 0x00, 0x4D, 0x4D, 0x3C)
+      store_end
+    end
+  end
+end  # class Chart
+
+end  # module Writeexcel

data/lib/writeexcel/col_info.rb

@@ -0,0 +1,87 @@
+module Writeexcel
+
+class Worksheet < BIFFWriter
+  require 'writeexcel/helper'
+
+  class ColInfo
+    attr_reader :level
+
+    #
+    #   new(firstcol, lastcol, width, [format, hidden, level, collapsed])
+    #
+    #   firstcol : First formatted column
+    #   lastcol  : Last formatted column
+    #   width    : Col width in user units, 8.43 is default
+    #   format   : format object
+    #   hidden   : hidden flag
+    #   level    : outline level
+    #   collapsed : ?
+    #
+    def initialize(*args)
+      @firstcol, @lastcol, @width, @format, @hidden, @level, @collapsed = args
+      @width ||= 8.43  # default width
+      @level ||= 0     # default level
+    end
+
+    # Write BIFF record COLINFO to define column widths
+    #
+    # Note: The SDK says the record length is 0x0B but Excel writes a 0x0C
+    # length record.
+    #
+    def biff_record
+      record   = 0x007D          # Record identifier
+      length   = 0x000B          # Number of bytes to follow
+
+      coldx    = (pixels * 256 / 7).to_i   # Col width in internal units
+      reserved = 0x00                      # Reserved
+
+      header = [record, length].pack("vv")
+      data   = [@firstcol, @lastcol, coldx,
+                ixfe, grbit, reserved].pack("vvvvvC")
+      [header, data]
+    end
+
+    # Excel rounds the column width to the nearest pixel. Therefore we first
+    # convert to pixels and then to the internal units. The pixel to users-units
+    # relationship is different for values less than 1.
+    #
+    def pixels
+      if @width < 1
+        result = @width * 12
+      else
+        result = @width * 7 + 5
+      end
+      result.to_i
+    end
+
+    def ixfe
+      if @format && @format.respond_to?(:xf_index)
+        ixfe = @format.xf_index
+      else
+        ixfe = 0x0F
+      end
+    end
+
+    # Set the limits for the outline levels (0 <= x <= 7).
+    def level
+      if @level < 0
+        0
+      elsif 7 < @level
+        7
+      else
+        @level
+      end
+    end
+
+    # Set the options flags. (See set_row() for more details).
+    def grbit
+      grbit    = 0x0000                    # Option flags
+      grbit |= 0x0001 if @hidden && @hidden != 0
+      grbit |= level << 8
+      grbit |= 0x1000 if @collapsed && @collapsed != 0
+      grbit
+    end
+  end
+end
+
+end

data/lib/writeexcel/colors.rb

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+
+module Writeexcel
+
+class Colors
+  COLORS = {
+    :aqua    => 0x0F,
+    :cyan    => 0x0F,
+    :black   => 0x08,
+    :blue    => 0x0C,
+    :brown   => 0x10,
+    :magenta => 0x0E,
+    :fuchsia => 0x0E,
+    :gray    => 0x17,
+    :grey    => 0x17,
+    :green   => 0x11,
+    :lime    => 0x0B,
+    :navy    => 0x12,
+    :orange  => 0x35,
+    :pink    => 0x21,
+    :purple  => 0x14,
+    :red     => 0x0A,
+    :silver  => 0x16,
+    :white   => 0x09,
+    :yellow  => 0x0D,
+  }   # :nodoc:
+
+  ###############################################################################
+  #
+  # get_color(colour)
+  #
+  # Used in conjunction with the set_xxx_color methods to convert a color
+  # string into a number. Color range is 0..63 but we will restrict it
+  # to 8..63 to comply with Gnumeric. Colors 0..7 are repeated in 8..15.
+  #
+  def get_color(color = nil) # :nodoc:
+    if color.respond_to?(:to_int) && color.respond_to?(:+)
+      # the default color if arg is outside range,
+      if color < 0 || 63 < color
+        0x7FFF
+      # or an index < 8 mapped into the correct range,
+      elsif color < 8
+        (color + 8).to_i
+      # or an integer in the valid range
+      else
+        color.to_i
+      end
+    elsif color.respond_to?(:to_sym)
+      color = color.downcase.to_sym if color.respond_to?(:to_str)
+      # or the color string converted to an integer,
+      if COLORS.has_key?(color)
+        COLORS[color]
+      # or the default color if string is unrecognised,
+      else
+        0x7FFF
+      end
+    else
+      0x7FFF
+    end
+  end
+
+  def inspect
+    to_s
+  end
+end  # class Colors
+
+end  # module Writeexcel
+

data/lib/writeexcel/comments.rb

@@ -0,0 +1,460 @@
+module Writeexcel
+
+class Worksheet < BIFFWriter
+  require 'writeexcel/helper'
+
+  class Collection
+    def initialize
+      @items = {}
+    end
+
+    def <<(item)
+      if @items[item.row]
+        @items[item.row][item.col] = item
+      else
+        @items[item.row] = { item.col => item }
+      end
+    end
+
+    def array
+      return @array if @array
+
+      @array = []
+      @items.keys.sort.each do |row|
+        @items[row].keys.sort.each do |col|
+          @array << @items[row][col]
+        end
+      end
+      @array
+    end
+
+  end
+
+  class Comments < Collection
+    attr_writer :visible
+
+    def initialize
+      super
+      @visible  = false
+    end
+
+    def visible?
+      @visible
+    end
+  end
+
+  class Comment
+    attr_reader :row, :col, :string, :encoding, :author, :author_encoding, :visible, :color, :vertices
+
+    def initialize(worksheet, row, col, string, options = {})
+      @worksheet = worksheet
+      @row, @col = row, col
+      @params = params_with(options)
+      @string, @params[:encoding] = string_and_encoding(string, @params[:encoding], 'comment')
+
+      # Limit the string to the max number of chars (not bytes).
+      max_len = 32767
+      max_len = max_len * 2 if @params[:encoding] != 0
+
+      if @string.bytesize > max_len
+        @string = @string[0 .. max_len]
+      end
+      @encoding        = @params[:encoding]
+      @author          = @params[:author]
+      @author_encoding = @params[:author_encoding]
+      @visible         = @params[:visible]
+      @color           = @params[:color]
+      @vertices        = calc_vertices
+    end
+
+    def store_comment_record(i, num_objects, num_comments, spid)
+      str_len  = string.bytesize
+      str_len  = str_len / 2 if encoding != 0 # Num of chars not bytes.
+
+      spid = store_comment_mso_drawing_record(i, num_objects, num_comments, spid, visible, color, vertices)
+      store_obj_comment(num_objects + i + 1)
+      store_mso_drawing_text_box
+      store_txo(str_len)
+      store_txo_continue_1(string, encoding)
+      formats  = [[0, 9], [str_len, 0]]
+      store_txo_continue_2(formats)
+      spid
+    end
+
+    #
+    # Write the worksheet NOTE record that is part of cell comments.
+    #
+    def store_note_record(obj_id)   #:nodoc:
+      comment_author = author
+      comment_author_enc = author_encoding
+      ruby_19 { comment_author = [comment_author].pack('a*') if comment_author.ascii_only? }
+      record      = 0x001C               # Record identifier
+      length      = 0x000C               # Bytes to follow
+
+      comment_author     = '' unless comment_author
+      comment_author_enc = 0  unless author_encoding
+
+      # Use the visible flag if set by the user or else use the worksheet value.
+      # The flag is also set in store_mso_opt_comment() but with the opposite
+      # value.
+      if visible
+        comment_visible = visible != 0                 ? 0x0002 : 0x0000
+      else
+        comment_visible = @worksheet.comments_visible? ? 0x0002 : 0x0000
+      end
+
+      # Get the number of chars in the author string (not bytes).
+      num_chars  = comment_author.bytesize
+      num_chars  = num_chars / 2 if comment_author_enc != 0 && comment_author_enc
+
+      # Null terminate the author string.
+      comment_author =
+        ruby_18 { comment_author + "\0" } ||
+        ruby_19 { comment_author.force_encoding('BINARY') + "\0".force_encoding('BINARY') }
+
+      # Pack the record.
+      data    = [@row, @col, comment_visible, obj_id, num_chars, comment_author_enc].pack("vvvvvC")
+
+      length  = data.bytesize + comment_author.bytesize
+      header  = [record, length].pack("vv")
+
+      append(header, data, comment_author)
+    end
+
+    #
+    # Write the Escher Opt record that is part of MSODRAWING.
+    #
+    def store_mso_opt_comment(spid, visible = nil, colour = 0x50)   #:nodoc:
+      type        = 0xF00B
+      version     = 3
+      instance    = 9
+      data        = ''
+      length      = 54
+
+      # Use the visible flag if set by the user or else use the worksheet value.
+      # Note that the value used is the opposite of Comment#note_record.
+      #
+      if visible
+        visible = visible != 0       ? 0x0000 : 0x0002
+      else
+        visible = @worksheet.comments_visible? ? 0x0000 : 0x0002
+      end
+
+      data = [spid].pack('V')                            +
+      ['0000BF00080008005801000000008101'].pack("H*") +
+      [colour].pack("C")                              +
+      ['000008830150000008BF011000110001'+'02000000003F0203000300BF03'].pack("H*")  +
+      [visible].pack('v')                             +
+      ['0A00'].pack('H*')
+
+      @worksheet.add_mso_generic(type, version, instance, data, length)
+    end
+
+    #
+    # OBJ record that is part of cell comments.
+    #    obj_id      # Object ID number.
+    #
+    def obj_comment_record(obj_id)   #:nodoc:
+      record      = 0x005D   # Record identifier
+      length      = 0x0034   # Bytes to follow
+
+      obj_type    = 0x0019   # Object type (comment).
+      data        = ''       # Record data.
+
+      sub_record  = 0x0000   # Sub-record identifier.
+      sub_length  = 0x0000   # Length of sub-record.
+      sub_data    = ''       # Data of sub-record.
+      options     = 0x4011
+      reserved    = 0x0000
+
+      # Add ftCmo (common object data) subobject
+      sub_record     = 0x0015   # ftCmo
+      sub_length     = 0x0012
+      sub_data       = [obj_type, obj_id, options, reserved, reserved, reserved].pack( "vvvVVV")
+      data           = [sub_record, sub_length].pack("vv") + sub_data
+
+      # Add ftNts (note structure) subobject
+      sub_record  = 0x000D   # ftNts
+      sub_length  = 0x0016
+      sub_data    = [reserved,reserved,reserved,reserved,reserved,reserved].pack( "VVVVVv")
+      data        += [sub_record, sub_length].pack("vv") + sub_data
+
+      # Add ftEnd (end of object) subobject
+      sub_record  = 0x0000   # ftNts
+      sub_length  = 0x0000
+      data        += [sub_record, sub_length].pack("vv")
+
+      # Pack the record.
+      header      = [record, length].pack("vv")
+
+      header + data
+    end
+
+    private
+
+    def params_with(options)
+      params = default_params.update(options)
+
+      # Ensure that a width and height have been set.
+      params[:width]  = default_width  unless params[:width]  && params[:width] != 0
+      params[:width]  = params[:width] * params[:x_scale]  if params[:x_scale] != 0
+      params[:height] = default_height unless params[:height] && params[:height] != 0
+      params[:height] = params[:height] * params[:y_scale] if params[:y_scale] != 0
+
+      params[:author], params[:author_encoding] =
+          string_and_encoding(params[:author], params[:author_encoding], 'author')
+
+      # Set the comment background colour.
+      params[:color] = background_color(params[:color])
+
+      # Set the default start cell and offsets for the comment. These are
+      # generally fixed in relation to the parent cell. However there are
+      # some edge cases for cells at the, er, edges.
+      #
+      params[:start_row] = default_start_row unless params[:start_row]
+      params[:y_offset]  = default_y_offset  unless params[:y_offset]
+      params[:start_col] = default_start_col unless params[:start_col]
+      params[:x_offset]  = default_x_offset  unless params[:x_offset]
+
+      params
+    end
+
+    def default_params
+      {
+        :author          => '',
+        :author_encoding => 0,
+        :encoding        => 0,
+        :color           => nil,
+        :start_cell      => nil,
+        :start_col       => nil,
+        :start_row       => nil,
+        :visible         => nil,
+        :width           => default_width,
+        :height          => default_height,
+        :x_offset        => nil,
+        :x_scale         => 1,
+        :y_offset        => nil,
+        :y_scale         => 1
+      }
+    end
+
+    def default_width
+      128
+    end
+
+    def default_height
+      74
+    end
+
+    def default_start_row
+      case @row
+      when 0     then 0
+      when 65533 then 65529
+      when 65534 then 65530
+      when 65535 then 65531
+      else            @row -1
+      end
+    end
+
+    def default_y_offset
+      case @row
+      when 0     then 2
+      when 65533 then 4
+      when 65534 then 4
+      when 65535 then 2
+      else            7
+      end
+    end
+
+    def default_start_col
+      case @col
+      when 253   then 250
+      when 254   then 251
+      when 255   then 252
+      else            @col + 1
+      end
+    end
+
+    def default_x_offset
+      case @col
+      when 253   then 49
+      when 254   then 49
+      when 255   then 49
+      else            15
+      end
+    end
+
+    def string_and_encoding(string, encoding, type)
+      string = convert_to_ascii_if_ascii(string)
+      if encoding != 0
+        raise "Uneven number of bytes in #{type} string" if string.bytesize % 2 != 0
+        # Change from UTF-16BE to UTF-16LE
+        string = utf16be_to_16le(string)
+      # Handle utf8 strings
+      else
+        if is_utf8?(string)
+          string = NKF.nkf('-w16L0 -m0 -W', string)
+          ruby_19 { string.force_encoding('UTF-16LE') }
+          encoding = 1
+        end
+      end
+      [string, encoding]
+    end
+
+    def background_color(color)
+      color = Colors.new.get_color(color)
+      color = 0x50 if color == 0x7FFF  # Default color.
+      color
+    end
+
+    # Calculate the positions of comment object.
+    def calc_vertices
+      @worksheet.position_object( @params[:start_col],
+        @params[:start_row],
+        @params[:x_offset],
+        @params[:y_offset],
+        @params[:width],
+        @params[:height]
+      )
+    end
+
+    def store_comment_mso_drawing_record(i, num_objects, num_comments, spid, visible, color, vertices)
+      if i == 0 && num_objects == 0
+        # Write the parent MSODRAWIING record.
+        dg_length   = 200 + 128 * (num_comments - 1)
+        spgr_length = 176 + 128 * (num_comments - 1)
+
+        data = @worksheet.store_parent_mso_record(dg_length, spgr_length, spid)
+        spid += 1
+      else
+        data = ''
+      end
+      data += @worksheet.store_mso_sp_container(120) + @worksheet.store_mso_sp(202, spid, 0x0A00)
+      spid += 1
+      data +=
+        store_mso_opt_comment(0x80, visible, color) +
+        @worksheet.store_mso_client_anchor(3, *vertices)               +
+        @worksheet.store_mso_client_data
+      record      = 0x00EC           # Record identifier
+      length      = data.bytesize
+      header      = [record, length].pack("vv")
+      append(header, data)
+
+      spid
+    end
+
+    def store_obj_comment(obj_id)
+      append(obj_comment_record(obj_id))
+    end
+
+    #
+    # Write the MSODRAWING ClientTextbox record that is part of comments.
+    #
+    def store_mso_drawing_text_box   #:nodoc:
+      record      = 0x00EC           # Record identifier
+      length      = 0x0008           # Bytes to follow
+
+      data        = store_mso_client_text_box
+      header  = [record, length].pack('vv')
+
+      append(header, data)
+    end
+
+    #
+    # Write the Escher ClientTextbox record that is part of MSODRAWING.
+    #
+    def store_mso_client_text_box   #:nodoc:
+      type        = 0xF00D
+      version     = 0
+      instance    = 0
+      data        = ''
+      length      = 0
+
+      @worksheet.add_mso_generic(type, version, instance, data, length)
+    end
+
+    #
+    # Write the worksheet TXO record that is part of cell comments.
+    #    string_len           # Length of the note text.
+    #    format_len           # Length of the format runs.
+    #    rotation             # Options
+    #
+    def store_txo(string_len, format_len = 16, rotation = 0)   #:nodoc:
+      record      = 0x01B6               # Record identifier
+      length      = 0x0012               # Bytes to follow
+
+      grbit       = 0x0212               # Options
+      reserved    = 0x0000               # Options
+
+      # Pack the record.
+      header  = [record, length].pack('vv')
+      data    = [grbit, rotation, reserved, reserved, string_len, format_len, reserved].pack("vvVvvvV")
+      append(header, data)
+    end
+
+    #
+    # Write the first CONTINUE record to follow the TXO record. It contains the
+    # text data.
+    #    string               # Comment string.
+    #    encoding             # Encoding of the string.
+    #
+    def store_txo_continue_1(string, encoding = 0)   #:nodoc:
+      # Split long comment strings into smaller continue blocks if necessary.
+      # We can't let BIFFwriter::_add_continue() handled this since an extra
+      # encoding byte has to be added similar to the SST block.
+      #
+      # We make the limit size smaller than the add_continue() size and even
+      # so that UTF16 chars occur in the same block.
+      #
+      limit = 8218
+      while string.bytesize > limit
+        string[0 .. limit] = ""
+        tmp_str = string
+        data    = [encoding].pack("C") +
+          ruby_18 { tmp_str } ||
+          ruby_19 { tmp_str.force_encoding('ASCII-8BIT') }
+        length  = data.bytesize
+        header  = [record, length].pack('vv')
+
+        append(header, data)
+      end
+
+      # Pack the record.
+      data    =
+        ruby_18 { [encoding].pack("C") + string } ||
+        ruby_19 { [encoding].pack("C") + string.force_encoding('ASCII-8BIT') }
+
+      record      = 0x003C               # Record identifier
+      length  = data.bytesize
+      header  = [record, length].pack('vv')
+
+      append(header, data)
+    end
+
+    #
+    # Write the second CONTINUE record to follow the TXO record. It contains the
+    # formatting information for the string.
+    #    formats           # Formatting information
+    #
+    def store_txo_continue_2(formats)   #:nodoc:
+      # Pack the record.
+      data = ''
+
+      formats.each do |a_ref|
+        data += [a_ref[0], a_ref[1], 0x0].pack('vvV')
+      end
+
+      record      = 0x003C               # Record identifier
+      length  = data.bytesize
+      header  = [record, length].pack("vv")
+
+      append(header, data)
+    end
+
+    def append(*args)
+      @worksheet.append(*args)
+    end
+  end
+end
+
+end