# -*- coding: utf-8 -*- ############################################################################### # # Workbook - A writer class for Excel Workbooks. # # # 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 # require 'nkf' require 'forwardable' require 'writeexcel/biffwriter' require 'writeexcel/worksheet' require 'writeexcel/chart' require 'writeexcel/format' require 'writeexcel/formula' require 'writeexcel/olewriter' require 'writeexcel/storage_lite' require 'writeexcel/compatibility' require 'writeexcel/shared_string_table' require 'writeexcel/worksheets' class Workbook < BIFFWriter require 'writeexcel/properties' require 'writeexcel/helper' extend Forwardable attr_reader :url_format, :parser, :tempdir, :date_1904 attr_reader :compatibility, :palette attr_reader :ext_refs attr_reader :worksheets BOF = 12 # :nodoc: EOF = 4 # :nodoc: # # _file_ is a filename (as string) or io object where to out spreadsheet data. # you can set default format of workbook using _default_formats_. # # A new Excel workbook is created using the new() constructor which accepts # either a filename or an IO object as a parameter. The following example # creates a new Excel file based on a filename: # # workbook = WriteExcel.new('filename.xls') # worksheet = workbook.add_worksheet # worksheet.write(0, 0, 'Hi Excel!') # # Here are some other examples of using new(): # # workbook1 = WriteExcel.new(filename) # workbook2 = WriteExcel.new('/tmp/filename.xls') # workbook3 = WriteExcel.new("c:\\tmp\\filename.xls") # workbook4 = WriteExcel.new('c:\tmp\filename.xls') # # The last two examples demonstrates how to create a file on DOS or # Windows where it is necessary to either escape the directory # separator \ or to use single quotes to ensure that it isn't interpolated. # # The new() constructor returns a WriteExcel object that you can use to add # worksheets and store data. # # If the file cannot be created, due to file permissions or some other reason, # new will raise Exception Errno::EXXX. # # You can also pass a valid IO object to the new() constructor.: # require 'stringio' # # io = StringIO.new # workbook = WriteExcel.new(io) # After workbook.close, you can get excel data as io.string # # And, you can also pass default format properties. # # workbook = WriteExcel.new(filename, :font => 'Courier New', :size => 11) # def initialize(file, default_formats = {}) super() @file = file @default_formats = default_formats @parser = Writeexcel::Formula.new(@byte_order) @tempdir = nil @date_1904 = false @xf_index = 0 @biffsize = 0 @sheet_count = 0 @chart_count = 0 @codepage = 0x04E4 @country = 1 @worksheets = Worksheets.new @formats = [] @palette = [] @biff_only = 0 @internal_fh = 0 @fh_out = "" @shared_string_table = SharedStringTable.new @extsst_offsets = [] # array of [global_offset, local_offset] @extsst_buckets = 0 @extsst_bucket_size = 0 @ext_refs = {} @mso_clusters = [] @mso_size = 0 @hideobj = false @summary = '' @doc_summary = '' @localtime = Time.now @defined_names = [] setup_built_in_formats(default_formats) # Add the default format for hyperlinks @url_format = add_format(:color => 'blue', :underline => 1) if file.respond_to?(:to_str) && file != '' @fh_out = open(file, "wb") @internal_fh = 1 else @fh_out = file end # Set colour palette. set_palette_xl97 end # # Calls finalization methods and explicitly close the OLEwriter files # handle. # # An explicit close() is required if the file must be closed prior to performing # some external action on it such as copying it, reading its size or attaching # it to an email. # # In general, if you create a file with a size of 0 bytes or you fail to create # a file you need to call close(). # def close return if fileclosed? # Prevent close() from being called twice. @fileclosed = true store_workbook cleanup end # get array of Worksheet objects # # :call-seq: # sheets -> array of all Wordsheet object # sheets(1, 3, 4) -> array of spcified Worksheet object. # # The sheets() method returns a array, or a sliced array, of the worksheets # in a workbook. # # If no arguments are passed the method returns a list of all the worksheets # in the workbook. This is useful if you want to repeat an operation on each # worksheet: # # workbook.sheets.each do |worksheet| # print worksheet.get_name # end # # You can also specify a slice list to return one or more worksheet objects: # # worksheet = workbook.sheets(0) # worksheet.write('A1', 'Hello') # # you can write the above example as: # # workbook.sheets(0).write('A1', 'Hello') # # The following example returns the first and last worksheet in a workbook: # # workbook.sheets(0, -1).each do |sheet| # # Do something # end # def sheets(*args) if args.empty? @worksheets else args.collect{|i| @worksheets[i] } end end # # Add a new worksheet to the Excel workbook. # # if _sheetname_ is UTF-16BE format, pass true as _name_utf16be_. # # At least one worksheet should be added to a new workbook. A worksheet is # used to write data into cells: # # worksheet1 = workbook.add_worksheet # Sheet1 # worksheet2 = workbook.add_worksheet('Foglio2') # Foglio2 # worksheet3 = workbook.add_worksheet('Data') # Data # worksheet4 = workbook.add_worksheet # Sheet4 # # If _sheetname_ is not specified the default Excel convention will be followed, # i.e. Sheet1, Sheet2, etc. The utf_16_be parameter is optional, see below. # # The worksheet name must be a valid Excel worksheet name, i.e. it cannot # contain any of the following characters, [ ] : * ? / \ # and it must be less than 32 characters. In addition, you cannot use the same, # case insensitive, _sheetname_ for more than one worksheet. # # This method will also handle strings in UTF-8 format. # # worksheet = workbook.add_worksheet("シート名") # # UTF-16BE worksheet names using an additional optional parameter: # # name = [0x263a].pack('n') # worksheet = workbook.add_worksheet(name, true) # Smiley # def add_worksheet(sheetname = '', name_utf16be = false) name, name_utf16be = check_sheetname(sheetname, name_utf16be) init_data = [ self, name, name_utf16be ] worksheet = Writeexcel::Worksheet.new(*init_data) @worksheets << worksheet # Store ref for iterator @parser.set_ext_sheets(name, worksheet.index) # Store names in Formula.rb worksheet end # # Create a chart for embedding or as as new sheet. # # This method is use to create a new chart either as a standalone worksheet # (the default) or as an embeddable object that can be inserted into a # worksheet via the insert_chart() Worksheet method. # # chart = workbook.add_chart(:type => 'Chart::Column') # # The properties that can be set are: # # :type (required) # :name (optional) # :name_utf16be (optional) # :embedded (optional) # # * :type # # This is a required parameter. It defines the type of chart that will be created. # # chart = workbook.add_chart(:type => 'Chart::Line') # # The available types are: # # 'Chart::Column' # 'Chart::Bar' # 'Chart::Line' # 'Chart::Area' # 'Chart::Pie' # 'Chart::Scatter' # 'Chart::Stock' # # * :name # # Set the name for the chart sheet. The name property is optional and # if it isn't supplied will default to Chart1 .. n. The name must be # a valid Excel worksheet name. See add_worksheet() for more details # on valid sheet names. The :name property can be omitted for embedded # charts. # # chart = workbook.add_chart( # :type => 'Chart::Line', # :name => 'Results Chart' # ) # # * :name_utf16be # # if :name is UTF-16BE format, pass true as :name_utf16be # # * :encoding # # if :name is UTF-16BE format, pass 1 as :encoding. # This key is obsolete in v0.7 or later. Use :name_utf16be instead. # # * :embedded # # Specifies true that the Chart object will be inserted in a worksheet via # the insert_chart() Worksheet method. It is an error to try insert a # Chart that doesn't have this flag set. # # chart = workbook.add_chart(:type => 'Chart::Line', :embedded => true) # # # Configure the chart. # ... # # # Insert the chart into the a worksheet. # worksheet.insert_chart('E2', chart) # # See WriteExcel::Chart for details on how to configure the # chart object once it is created. See also the chart_*.rb programs in the # examples directory of the distro. # def add_chart(properties) name = '' name_utf16be = false # Type must be specified so we can create the required chart instance. type = properties[:type] raise "Must define chart type in add_chart()" if type.nil? # Ensure that the chart defaults to non embedded. embedded = properties[:embedded] # Check the worksheet name for non-embedded charts. unless embedded properties[:name_utf16be] = true if properties[:encoding] == 1 name, name_utf16be = check_sheetname(properties[:name], properties[:name_utf16be], true) end init_data = [ self, name, name_utf16be ] chart = Writeexcel::Chart.factory(type, *init_data) # If the chart isn't embedded let the workbook control it. if !embedded @worksheets << chart # Store ref for iterator else chart.set_embedded_config_data end chart end # # Add an externally created chart. # # This method is use to include externally generated charts in a WriteExcel # file. # # chart = workbook.add_chart_ext('chart01.bin', 'Chart1') # # This feature is semi-deprecated in favour of the "native" charts created # using add_chart(). Read external_charts.txt in the external_charts # directory of the distro for a full explanation. # def add_chart_ext(filename, chartname, name_utf16be = false) type = 'extarnal' name, name_utf16be = check_sheetname(chartname, name_utf16be) init_data = [ filename, name, name_utf16be ] chart = Writeexcel::Chart.factory(self, type, init_data) @worksheets << chart # Store ref for iterator chart end # # The add_format method can be used to create new Format objects which are # used to apply formatting to a cell. You can either define the properties # at creation time via a hash of property values or later via method calls. # # format1 = workbook.add_format(props) # Set properties at creation # format2 = workbook.add_format # Set properties later # # See the "CELL FORMATTING" section for more details about Format properties and how to set them. # def add_format(*args) fmts = {} args.each { |arg| fmts = fmts.merge(arg) } format = Writeexcel::Format.new(@xf_index, @default_formats.merge(fmts)) @xf_index += 1 @formats.push format # Store format reference format end # # Set the compatibility mode. # # This method is used to improve compatibility with third party # applications that read Excel files. # # workbook.compatibility_mode # # An Excel file is comprised of binary records that describe properties of # a spreadsheet. Excel is reasonably liberal about this and, outside of a # core subset, it doesn't require every possible record to be present when # it reads a file. This is also true of Gnumeric and OpenOffice.Org Calc. # # WriteExcel takes advantage of this fact to omit some records in order to # minimise the amount of data stored in memory and to simplify and speed up # the writing of files. However, some third party applications that read # Excel files often expect certain records to be present. In # "compatibility mode" WriteExcel writes these records and tries to be as # close to an Excel generated file as possible. # # Applications that require compatibility_mode() are Apache POI, # Apple Numbers, and Quickoffice on Nokia, Palm and other devices. You should # also use compatibility_mode() if your Excel file will be used as an external # data source by another Excel file. # # If you encounter other situations that require compatibility_mode(), # please let me know. # # It should be noted that compatibility_mode() requires additional data to be # stored in memory and additional processing. This incurs a memory and speed # penalty and may not be suitable for very large files (>20MB). # # You must call compatibility_mode() before calling add_worksheet(). # # # Excel doesn't require every possible Biff record to be present in a file. # In particular if the indexing records INDEX, ROW and DBCELL aren't present # it just ignores the fact and reads the cells anyway. This is also true of # the EXTSST record. Gnumeric and OOo also take this approach. This allows # WriteExcel to ignore these records in order to minimise the amount of data # stored in memory. However, other third party applications that read Excel # files often expect these records to be present. In "compatibility mode" # WriteExcel writes these records and tries to be as close to an Excel # generated file as possible. # # This requires additional data to be stored in memory until the file is # about to be written. This incurs a memory and speed penalty and may not be # suitable for very large files. # def compatibility_mode(mode = true) unless sheets.empty? raise "compatibility_mode() must be called before add_worksheet()" end @compatibility = mode end # # Set the date system: false = 1900 (the default), true = 1904 # # Excel stores dates as real numbers where the integer part stores the # number of days since the epoch and the fractional part stores the # percentage of the day. The epoch can be either 1900 or 1904. Excel for # Windows uses 1900 and Excel for Macintosh uses 1904. However, Excel on # either platform will convert automatically between one system and # the other. # # WriteExcel stores dates in the 1900 format by default. If you wish to # change this you can call the set_1904() workbook method. You can query # the current value by calling the get_1904() workbook method. This returns # false for 1900 and true for 1904. # # See also "DATES AND TIME IN EXCEL" for more information about working # with Excel's date system. # # In general you probably won't need to use set_1904(). # def set_1904(mode = true) unless sheets.empty? raise "set_1904() must be called before add_worksheet()" end @date_1904 = (!mode || mode == 0) ? false : true end def get_1904 @date_1904 end # # Change the RGB components of the elements in the colour palette. # # The set_custom_color() method can be used to override one of the built-in # palette values with a more suitable colour. # # The value for _index_ should be in the range 8..63, see "COLOURS IN EXCEL". # # The default named colours use the following indices: # # 8 => black # 9 => white # 10 => red # 11 => lime # 12 => blue # 13 => yellow # 14 => magenta # 15 => cyan # 16 => brown # 17 => green # 18 => navy # 20 => purple # 22 => silver # 23 => gray # 33 => pink # 53 => orange # # A new colour is set using its RGB (red green blue) components. The red, # green and blue values must be in the range 0..255. You can determine the # required values in Excel using the Tools->Options->Colors->Modify dialog. # # The set_custom_color() workbook method can also be used with a HTML style # #rrggbb hex value: # # workbook.set_custom_color(40, 255, 102, 0 ) # Orange # workbook.set_custom_color(40, 0xFF, 0x66, 0x00) # Same thing # workbook.set_custom_color(40, '#FF6600' ) # Same thing # # font = workbook.add_format(:color => 40) # Use the modified colour # # The return value from set_custom_color() is the index of the colour that # was changed: # # ferrari = workbook.set_custom_color(40, 216, 12, 12) # # format = workbook.add_format( # :bg_color => $ferrari, # :pattern => 1, # :border => 1 # ) # def set_custom_color(index, red = nil, green = nil, blue = nil) # Match a HTML #xxyyzz style parameter if !red.nil? && red =~ /^#(\w\w)(\w\w)(\w\w)/ red = $1.hex green = $2.hex blue = $3.hex end # Check that the colour index is the right range if index < 8 || index > 64 raise "Color index #{index} outside range: 8 <= index <= 64" end # Check that the colour components are in the right range if (red < 0 || red > 255) || (green < 0 || green > 255) || (blue < 0 || blue > 255) raise "Color component outside range: 0 <= color <= 255" end index -=8 # Adjust colour index (wingless dragonfly) # Set the RGB value @palette[index] = [red, green, blue, 0] index + 8 end # # Change the default temp directory # # For speed and efficiency WriteExcel stores worksheet data in temporary # files prior to assembling the final workbook. # # If WriteExcel is unable to create these temporary files it will store # the required data in memory. This can be slow for large files. # # The problem occurs mainly with IIS on Windows although it could feasibly # occur on Unix systems as well. The problem generally occurs because the # default temp file directory is defined as C:/ or some other directory that # IIS doesn't provide write access to. # # To check if this might be a problem on a particular system you can run a # simple test program with -w or use warnings. This will generate a warning # if the module cannot create the required temporary files: # # #!/usr/bin/ruby -w # # require 'WriteExcel' # # workbook = WriteExcel.new('test.xls') # worksheet = workbook.add_worksheet # workbook.close # # To avoid this problem the set_tempdir() method can be used to specify a # directory that is accessible for the creation of temporary files. # # Even if the default temporary file directory is accessible you may wish # to specify an alternative location for security or maintenance reasons: # # workbook.set_tempdir('/tmp/writeexcel') # workbook.set_tempdir('c:\windows\temp\writeexcel') # # The directory for the temporary file must exist, set_tempdir() will not # create a new directory. # # One disadvantage of using the set_tempdir() method is that on some Windows # systems it will limit you to approximately 800 concurrent tempfiles. This # means that a single program running on one of these systems will be limited # to creating a total of 800 workbook and worksheet objects. You can run # multiple, non-concurrent programs to work around this if necessary. # def set_tempdir(dir = '') raise "#{dir} is not a valid directory" if dir != '' && !FileTest.directory?(dir) raise "set_tempdir must be called before add_worksheet" unless sheets.empty? @tempdir = dir end # # The default code page or character set used by WriteExcel is ANSI. This is # also the default used by Excel for Windows. Occasionally however it may be # necessary to change the code page via the set_codepage() method. # # Changing the code page may be required if your are using WriteExcel on the # Macintosh and you are using characters outside the ASCII 128 character set: # # workbook.set_codepage(1) # ANSI, MS Windows # workbook.set_codepage(2) # Apple Macintosh # # The set_codepage() method is rarely required. # def set_codepage(type = 1) if type == 2 @codepage = 0x8000 else @codepage = 0x04E4 end end # # store the country code. # # Some non-english versions of Excel may need this set to some value other # than 1 = "United States". In general the country code is equal to the # international dialling code. # def set_country(code = 1) @country = code end # # This method is used to defined a name that can be used to represent a # value, a single cell or a range of cells in a workbook. # # workbook.define_name('Exchange_rate', '=0.96') # workbook.define_name('Sales', '=Sheet1!$G$1:$H$10') # workbook.define_name('Sheet2!Sales', '=Sheet2!$G$1:$G$10') # # See the defined_name.rb program in the examples dir of the distro. # # Note: This currently a beta feature. More documentation and examples # will be added. # def define_name(name, formula, encoding = 0) sheet_index = 0 full_name = name.downcase if name =~ /^(.*)!(.*)$/ sheetname = $1 name = $2 sheet_index = 1 + @parser.get_sheet_index(sheetname) end # Strip the = sign at the beginning of the formula string formula = formula.sub(/^=/, '') # Parse the formula using the parser in Formula.pm parser = @parser # In order to raise formula errors from the point of view of the calling # program we use an eval block and re-raise the error from here. # tokens = parser.parse_formula(formula) # Force 2d ranges to be a reference class. tokens.collect! { |t| t.gsub(/_ref3d/, '_ref3dR') } tokens.collect! { |t| t.gsub(/_range3d/, '_range3dR') } # Parse the tokens into a formula string. formula = parser.parse_tokens(tokens) defined_names.push( { :name => name, :encoding => encoding, :sheet_index => sheet_index, :formula => formula } ) index = defined_names.size parser.set_ext_name(name, index) end # # Set the document properties such as Title, Author etc. These are written to # property sets in the OLE container. # # The set_properties method can be used to set the document properties of # the Excel file created by WriteExcel. These properties are visible when you # use the File->Properties menu option in Excel and are also available to # external applications that read or index windows files. # # The properties should be passed as a hash of values as follows: # # workbook.set_properties( # :title => 'This is an example spreadsheet', # :author => 'cxn03651', # :comments => 'Created with Ruby and WriteExcel', # ) # # The properties that can be set are: # # * :title # * :subject # * :author # * :manager # * :company # * :category # * :keywords # * :comments # # User defined properties are not supported due to effort required. # # You can also pass UTF-8 strings as properties. # # workbook.set_properties( # :subject => "住所録" # ) # # Usually WriteExcel allows you to use UTF-16. However, document properties # don't support UTF-16 for these type of strings. # # In order to promote the usefulness of Ruby and the WriteExcel module # consider adding a comment such as the following when using document # properties: # # workbook.set_properties( # ..., # :comments => 'Created with Ruby and writeexcel', # ..., # ) # # See also the properties.rb program in the examples directory of the distro. # def set_properties(params) # Ignore if no args were passed. return -1 if !params.respond_to?(:to_hash) || params.empty? params.each do |k, v| params[k] = convert_to_ascii_if_ascii(v) if v.respond_to?(:to_str) end # Check for valid input parameters. check_valid_params_for_properties(params) # Set the creation time unless specified by the user. params[:created] = @localtime unless params.has_key?(:created) # # Create the SummaryInformation property set. # # Get the codepage of the strings in the property set. properties = [:title, :subject, :author, :keywords, :comments, :last_author] params[:codepage] = get_property_set_codepage(params, properties) # Create an array of property set values. properties.unshift(:codepage) properties.push(:created) # Pack the property sets. @summary = create_summary_property_set(property_sets(properties, params)) # # Create the DocSummaryInformation property set. # # Get the codepage of the strings in the property set. properties = [:category, :manager, :company] params[:codepage] = get_property_set_codepage(params, properties) # Create an array of property set values. properties.unshift(:codepage) # Pack the property sets. @doc_summary = create_doc_summary_property_set(property_sets(properties, params)) # Set a flag for when the files is written. @add_doc_properties = true end def extsst_buckets # :nodoc: @extsst_buckets end def extsst_bucket_size # :nodoc: @extsst_bucket_size end def biff_only=(val) # :nodoc: @biff_only = val end def summary # :nodoc: @summary end def localtime=(val) # :nodoc: @localtime = val end def update_str_table(str) @shared_string_table << str end #========================================== # Internal method #========================================== private # Add the in-built style formats and the default cell format. def setup_built_in_formats(default_formats) # :nodoc: add_format(:type => 1) # 0 Normal add_format(:type => 1) # 1 RowLevel 1 add_format(:type => 1) # 2 RowLevel 2 add_format(:type => 1) # 3 RowLevel 3 add_format(:type => 1) # 4 RowLevel 4 add_format(:type => 1) # 5 RowLevel 5 add_format(:type => 1) # 6 RowLevel 6 add_format(:type => 1) # 7 RowLevel 7 add_format(:type => 1) # 8 ColLevel 1 add_format(:type => 1) # 9 ColLevel 2 add_format(:type => 1) # 10 ColLevel 3 add_format(:type => 1) # 11 ColLevel 4 add_format(:type => 1) # 12 ColLevel 5 add_format(:type => 1) # 13 ColLevel 6 add_format(:type => 1) # 14 ColLevel 7 add_format(default_formats) # 15 Cell XF add_format(:type => 1, :num_format => 0x2B) # 16 Comma add_format(:type => 1, :num_format => 0x29) # 17 Comma[0] add_format(:type => 1, :num_format => 0x2C) # 18 Currency add_format(:type => 1, :num_format => 0x2A) # 19 Currency[0] add_format(:type => 1, :num_format => 0x09) # 20 Percent end def fileclosed? @fileclosed || false end # # Check for valid worksheet names. We check the length, if it contains any # invalid characters and if the name is unique in the workbook. # def check_sheetname(name, name_utf16be = false, chart = nil) #:nodoc: # name_utf16be parameter may set 0/1 in v0.6.6 or earlier name_utf16be = false if name_utf16be == 0 name_utf16be = true if name_utf16be == 1 increment_sheet_chart_count(chart) if name.nil? || name == "" name_utf16be = false name = default_sheet_chart_name(chart) end ruby_19 { name = convert_to_ascii_if_ascii(name) } check_sheetname_length(name, name_utf16be) check_sheetname_even(name) if name_utf16be check_sheetname_valid_chars(name, name_utf16be) # Handle utf8 strings if is_utf8?(name) name = utf8_to_16be(name) name_utf16be = true end check_sheetname_uniq(name, name_utf16be) [name, name_utf16be] end # Increment the Sheet/Chart number used for default sheet names below. def increment_sheet_chart_count(chart) if chart @chart_count += 1 else @sheet_count += 1 end end # Supply default Sheet/Chart name if none has been defined. def default_sheet_chart_name(chart) if chart "Chart#{@chart_count}" else "Sheet#{@sheet_count}" end end def check_sheetname_length(name, name_utf16be) #:nodoc: # Check that sheetname is <= 31 (1 or 2 byte chars). Excel limit. limit = name_utf16be ? 62 : 31 raise "Sheetname $name must be <= 31 chars" if name.bytesize > limit end def check_sheetname_even(name) #:nodoc: # Check that Unicode sheetname has an even number of bytes if (name.bytesize % 2 != 0) raise "Odd number of bytes in Unicode worksheet name: #{name}" end end def check_sheetname_valid_chars(name, name_utf16be) #:nodoc: # Check that sheetname doesn't contain any invalid characters invalid_char = %r![\[\]:*?/\\]! if !name_utf16be && name =~ invalid_char # Check ASCII names raise "Invalid character []:*?/\\ in worksheet name: #{name}" else # Extract any 8bit clean chars from the UTF16 name and validate them. str = name.dup while str =~ /../m hi, lo = $~[0].unpack('aa') if hi == "\0" and lo =~ invalid_char raise 'Invalid character []:*?/\\ in worksheet name: ' + name end str = $~.post_match end end end # Check that the worksheet name doesn't already exist since this is a fatal # error in Excel 97. The check must also exclude case insensitive matches # since the names 'Sheet1' and 'sheet1' are equivalent. The tests also have # to take the name_utf16be into account. # def check_sheetname_uniq(name, name_utf16be) #:nodoc: @worksheets.each do |worksheet| name_a = name encd_a = name_utf16be name_b = worksheet.name encd_b = worksheet.is_name_utf16be? error = false if !encd_a and !encd_b error = (name_a.downcase == name_b.downcase) elsif !encd_a and encd_b name_a = ascii_to_16be(name_a) error = (name_a.downcase == name_b.downcase) elsif encd_a and !encd_b name_b = ascii_to_16be(name_b) error = (name_a.downcase == name_b.downcase) elsif encd_a and encd_b error = (name_a.downcase == name_b.downcase) # TODO : not converted yet. # We can't easily do a case insensitive test of the UTF16 names. # As a special case we check if all of the high bytes are nulls and # then do an ASCII style case insensitive test. # # Strip out the high bytes (funkily). # my $hi_a = grep {ord} $name_a =~ /(.)./sg; # my $hi_b = grep {ord} $name_b =~ /(.)./sg; # # if ($hi_a or $hi_b) { # $error = 1 if $name_a eq $name_b; # } # else { # $error = 1 if lc($name_a) eq lc($name_b); # } end if error raise "Worksheet name '#{name}', with case ignored, is already in use" end end end # # Sets the colour palette to the Excel 97+ default. # def set_palette_xl97 #:nodoc: @palette = [ [0x00, 0x00, 0x00, 0x00], # 8 [0xff, 0xff, 0xff, 0x00], # 9 [0xff, 0x00, 0x00, 0x00], # 10 [0x00, 0xff, 0x00, 0x00], # 11 [0x00, 0x00, 0xff, 0x00], # 12 [0xff, 0xff, 0x00, 0x00], # 13 [0xff, 0x00, 0xff, 0x00], # 14 [0x00, 0xff, 0xff, 0x00], # 15 [0x80, 0x00, 0x00, 0x00], # 16 [0x00, 0x80, 0x00, 0x00], # 17 [0x00, 0x00, 0x80, 0x00], # 18 [0x80, 0x80, 0x00, 0x00], # 19 [0x80, 0x00, 0x80, 0x00], # 20 [0x00, 0x80, 0x80, 0x00], # 21 [0xc0, 0xc0, 0xc0, 0x00], # 22 [0x80, 0x80, 0x80, 0x00], # 23 [0x99, 0x99, 0xff, 0x00], # 24 [0x99, 0x33, 0x66, 0x00], # 25 [0xff, 0xff, 0xcc, 0x00], # 26 [0xcc, 0xff, 0xff, 0x00], # 27 [0x66, 0x00, 0x66, 0x00], # 28 [0xff, 0x80, 0x80, 0x00], # 29 [0x00, 0x66, 0xcc, 0x00], # 30 [0xcc, 0xcc, 0xff, 0x00], # 31 [0x00, 0x00, 0x80, 0x00], # 32 [0xff, 0x00, 0xff, 0x00], # 33 [0xff, 0xff, 0x00, 0x00], # 34 [0x00, 0xff, 0xff, 0x00], # 35 [0x80, 0x00, 0x80, 0x00], # 36 [0x80, 0x00, 0x00, 0x00], # 37 [0x00, 0x80, 0x80, 0x00], # 38 [0x00, 0x00, 0xff, 0x00], # 39 [0x00, 0xcc, 0xff, 0x00], # 40 [0xcc, 0xff, 0xff, 0x00], # 41 [0xcc, 0xff, 0xcc, 0x00], # 42 [0xff, 0xff, 0x99, 0x00], # 43 [0x99, 0xcc, 0xff, 0x00], # 44 [0xff, 0x99, 0xcc, 0x00], # 45 [0xcc, 0x99, 0xff, 0x00], # 46 [0xff, 0xcc, 0x99, 0x00], # 47 [0x33, 0x66, 0xff, 0x00], # 48 [0x33, 0xcc, 0xcc, 0x00], # 49 [0x99, 0xcc, 0x00, 0x00], # 50 [0xff, 0xcc, 0x00, 0x00], # 51 [0xff, 0x99, 0x00, 0x00], # 52 [0xff, 0x66, 0x00, 0x00], # 53 [0x66, 0x66, 0x99, 0x00], # 54 [0x96, 0x96, 0x96, 0x00], # 55 [0x00, 0x33, 0x66, 0x00], # 56 [0x33, 0x99, 0x66, 0x00], # 57 [0x00, 0x33, 0x00, 0x00], # 58 [0x33, 0x33, 0x00, 0x00], # 59 [0x99, 0x33, 0x00, 0x00], # 60 [0x99, 0x33, 0x66, 0x00], # 61 [0x33, 0x33, 0x99, 0x00], # 62 [0x33, 0x33, 0x33, 0x00] # 63 ] end def property_set(property, params) #:nodoc: valid_properties[property][0..1] + [params[property]] end def property_sets(properties, params) #:nodoc: properties.select { |property| params[property.to_sym] }. collect do |property| property_set(property.to_sym, params) end end # List of valid input parameters. def valid_properties #:nodoc: { :codepage => [0x0001, 'VT_I2' ], :title => [0x0002, 'VT_LPSTR' ], :subject => [0x0003, 'VT_LPSTR' ], :author => [0x0004, 'VT_LPSTR' ], :keywords => [0x0005, 'VT_LPSTR' ], :comments => [0x0006, 'VT_LPSTR' ], :last_author => [0x0008, 'VT_LPSTR' ], :created => [0x000C, 'VT_FILETIME'], :category => [0x0002, 'VT_LPSTR' ], :manager => [0x000E, 'VT_LPSTR' ], :company => [0x000F, 'VT_LPSTR' ], :utf8 => 1 } end def check_valid_params_for_properties(params) #:nodoc: params.each_key do |k| unless valid_properties.has_key?(k) raise "Unknown parameter '#{k}' in set_properties()" end end end # # Get the character codepage used by the strings in a property set. If one of # the strings used is utf8 then the codepage is marked as utf8. Otherwise # Latin 1 is used (although in our case this is limited to 7bit ASCII). # def get_property_set_codepage(params, properties) #:nodoc: # Allow for manually marked utf8 strings. return 0xFDE9 unless params[:utf8].nil? properties.each do |property| next unless params.has_key?(property.to_sym) return 0xFDE9 if is_utf8?(params[property.to_sym]) end return 0x04E4 # Default codepage, Latin 1. end # # Assemble worksheets into a workbook and send the BIFF data to an OLE # storage. # def store_workbook #:nodoc: # Add a default worksheet if non have been added. add_worksheet if @worksheets.empty? # Calculate size required for MSO records and update worksheets. calc_mso_sizes # Ensure that at least one worksheet has been selected. unless @worksheets.activesheet @worksheets.activesheet = @worksheets.first @worksheets.activesheet.select end # Add Workbook globals add_workbook_globals # Calculate the offsets required by the BOUNDSHEET records calc_sheet_offsets # Add BOUNDSHEET records. @worksheets.each do |sheet| store_boundsheet(sheet) end # NOTE: If any records are added between here and EOF the # calc_sheet_offsets() should be updated to include the new length. store_country if @ext_refs.keys.size != 0 store_supbook store_externsheet store_names end add_mso_drawing_group store_shared_strings store_extsst # End Workbook globals store_eof # Store the workbook in an OLE container store_ole_file end def add_workbook_globals store_bof(0x0005) store_codepage store_window1 store_hideobj store_1904 store_all_fonts store_all_num_formats store_all_xfs store_all_styles store_palette end # # Store the workbook in an OLE container using the default handler or using # OLE::Storage_Lite if the workbook data is > ~ 7MB. # def store_ole_file #:nodoc: maxsize = 7_087_104 # maxsize = 1 if !add_doc_properties && @biffsize <= maxsize store_through_ole_writer else store_through_ole_storage_lite end end def store_through_ole_writer # Write the OLE file using OLEwriter if data <= 7MB ole = OLEWriter.new(@fh_out) # Write the BIFF data without the OLE container for testing. ole.biff_only = @biff_only # Indicate that we created the filehandle and want to close it. ole.internal_fh = @internal_fh ole.set_size(@biffsize) ole.write_header while tmp = get_data ole.write(tmp) end @worksheets.each do |worksheet| while tmp = worksheet.get_data ole.write(tmp) end end return ole.close end def store_through_ole_storage_lite # Create the Workbook stream. stream = 'Workbook'.unpack('C*').pack('v*') workbook = OLEStorageLitePPSFile.new(stream) workbook.set_file # use tempfile while tmp = get_data workbook.append(tmp) end @worksheets.each do |worksheet| while tmp = worksheet.get_data workbook.append(tmp) end end streams = [] streams << workbook # Create the properties streams, if any. if add_doc_properties stream = "\5SummaryInformation".unpack('C*').pack('v*') summary = OLEStorageLitePPSFile.new(stream, @summary) streams << summary stream = "\5DocumentSummaryInformation".unpack('C*').pack('v*') summary = OLEStorageLitePPSFile.new(stream, @doc_summary) streams << summary end # Create the OLE root document and add the substreams. localtime = @localtime.to_a[0..5] localtime[4] -= 1 # month localtime[5] -= 1900 ole_root = OLEStorageLitePPSRoot.new( localtime, localtime, streams ) ole_root.save(@file) # Close the filehandle if it was created internally. return @fh_out.close if @internal_fh != 0 end # # Calculate Worksheet BOF offsets records for use in the BOUNDSHEET records. # def calc_sheet_offsets #:nodoc: offset = @datasize # Add the length of the COUNTRY record offset += 8 # Add the length of the SST and associated CONTINUEs offset += calculate_shared_string_sizes # Add the length of the EXTSST record. offset += calculate_extsst_size(@shared_string_table.str_unique) # Add the length of the SUPBOOK, EXTERNSHEET and NAME records offset += calculate_extern_sizes # Add the length of the MSODRAWINGGROUP records including an extra 4 bytes # for any CONTINUE headers. See add_mso_drawing_group_continue(). mso_size = @mso_size mso_size += 4 * Integer((mso_size -1) / Float(@limit)) offset += mso_size @worksheets.each do |sheet| offset += BOF + sheet.name.bytesize end offset += EOF @worksheets.each do |sheet| sheet.offset = offset sheet.close offset += sheet.datasize end @biffsize = offset end # # Calculate the MSODRAWINGGROUP sizes and the indexes of the Worksheet # MSODRAWING records. # # In the following SPID is shape id, according to Escher nomenclature. # def calc_mso_sizes #:nodoc: mso_size = 0 # Size of the MSODRAWINGGROUP record max_spid = 1024 # spidMax drawings_saved = 0 # cdgSaved clusters = [] process_images # Add Bstore container size if there are images. mso_size += 8 unless @images_data.empty? # Iterate through the worksheets, calculate the MSODRAWINGGROUP parameters # and space required to store the record and the MSODRAWING parameters # required by each worksheet. # @worksheets.each do |sheet| next unless sheet.type == 0x0000 next if sheet.num_shapes == 1 mso_size, drawings_saved, max_spid, start_spid = sheet.push_object_ids(mso_size, drawings_saved, max_spid, start_spid, clusters) end # Calculate the MSODRAWINGGROUP size if we have stored some shapes. mso_size += 86 if mso_size != 0 # Smallest size is 86+8=94 shapes_saved = sheets.collect { |sheet| sheet.num_shapes }. select { |num_shapes| num_shapes > 1 }. inject(0) { |result, num_shapes| result + num_shapes } @mso_size = mso_size @mso_clusters = [ max_spid, clusters.size + 1, shapes_saved, drawings_saved, clusters ] end # # We need to process each image in each worksheet and extract information. # Some of this information is stored and used in the Workbook and some is # passed back into each Worksheet. The overall size for the image related # BIFF structures in the Workbook is calculated here. # # MSO size = 8 bytes for bstore_container + # 44 bytes for blip_store_entry + # 25 bytes for blip # = 77 + image size. # def process_images #:nodoc: images_seen = {} image_data = [] previous_images = [] image_id = 1 images_size = 0 @worksheets.each do |sheet| next unless sheet.type == 0x0000 next if sheet.images_size == 0 num_images = 0 image_mso_size = 0 sheet.images_array.each do |image| num_images += 1 unless images_seen[image.filename] # TODO should also match seen images based on checksum. image.id = image_id image.ref_count = 1 image.import # Also store new data for use in duplicate images. previous_images.push(image) # Store information required by the Workbook. image_data.push(image) # Keep track of overall data size. images_size += image.size + 61 # Size for bstore container. image_mso_size += image.size + 69 # Size for dgg container. images_seen[image.filename] = image_id image_id += 1 else # We've processed this file already. index = images_seen[image.filename] -1 # Increase image reference count. image_data[index].ref_count += 1 # Add previously calculated data back onto the Worksheet array. # image_id, type, width, height image.id = previous_images[index].id image.type = previous_images[index].type image.width = previous_images[index].width image.height = previous_images[index].height end end # Store information required by the Worksheet. sheet.num_images = num_images sheet.image_mso_size = image_mso_size end # Store information required by the Workbook. @images_size = images_size @images_data = image_data # Store the data for MSODRAWINGGROUP. end # # Store the Excel FONT records. # def store_all_fonts #:nodoc: format = @formats[15] # The default cell format. font = format.get_font # Fonts are 0-indexed. According to the SDK there is no index 4, 4.times { append(font) } # Add the default fonts for charts and comments. This aren't connected # to XF formats. Note, the font size, and some other properties of # chart fonts are set in the FBI record of the chart. # Index 5. Axis numbers. tmp_format = Writeexcel::Format.new( nil, :font_only => 1 ) append(tmp_format.get_font) # Index 6. Series names. tmp_format = Writeexcel::Format.new( nil, :font_only => 1 ) append(tmp_format.get_font) # Index 7. Title. tmp_format = Writeexcel::Format.new( nil, :font_only => 1, :bold => 1 ) append(tmp_format.get_font) # Index 8. Axes. tmp_format = Writeexcel::Format.new( nil, :font_only => 1, :bold => 1 ) append(tmp_format.get_font) # Index 9. Comments. tmp_format = Writeexcel::Format.new( nil, :font_only => 1, :font => 'Tahoma', :size => 8 ) append(tmp_format.get_font) # Iterate through the XF objects and write a FONT record if it isn't the # same as the default FONT and if it hasn't already been used. # fonts = {} index = 10 # The first user defined FONT key = format.get_font_key # The default font for cell formats. fonts[key] = 0 # Index of the default font # Fonts that are marked as '_font_only' are always stored. These are used # mainly for charts and may not have an associated XF record. @formats.each do |fmt| key = fmt.get_font_key if fmt.font_only == 0 and !fonts[key].nil? # FONT has already been used fmt.font_index = fonts[key] else # Add a new FONT record if fmt.font_only == 0 fonts[key] = index end fmt.font_index = index index += 1 font = fmt.get_font append(font) end end end # # Store user defined numerical formats i.e. FORMAT records # def store_all_num_formats #:nodoc: num_formats = {} index = 164 # User defined FORMAT records start from 0xA4 # Iterate through the XF objects and write a FORMAT record if it isn't a # built-in format type and if the FORMAT string hasn't already been used. # @formats.each do |format| num_format = format.num_format encoding = format.num_format_enc # Check if $num_format is an index to a built-in format. # Also check for a string of zeros, which is a valid format string # but would evaluate to zero. # unless num_format.to_s =~ /^0+\d/ next if num_format.to_s =~ /^\d+$/ # built-in end if num_formats[num_format] # FORMAT has already been used format.num_format = num_formats[num_format] else # Add a new FORMAT num_formats[num_format] = index format.num_format = index store_num_format(num_format, index, encoding) index += 1 end end end # # Write all XF records. # def store_all_xfs #:nodoc: @formats.each do |format| xf = format.get_xf append(xf) end end # # Write all STYLE records. # def store_all_styles #:nodoc: # Excel adds the built-in styles in alphabetical order. built_ins = [ [0x03, 16], # Comma [0x06, 17], # Comma[0] [0x04, 18], # Currency [0x07, 19], # Currency[0] [0x00, 0], # Normal [0x05, 20] # Percent # We don't deal with these styles yet. #[0x08, 21], # Hyperlink #[0x02, 8], # ColLevel_n #[0x01, 1], # RowLevel_n ] built_ins.each do |aref| type = aref[0] xf_index = aref[1] store_style(type, xf_index) end end # # Write the NAME record to define the print area and the repeat rows and cols. # def store_names # :nodoc: # Create the user defined names. defined_names.each do |defined_name| store_name( defined_name[:name], defined_name[:encoding], defined_name[:sheet_index], defined_name[:formula] ) end # Sort the worksheets into alphabetical order by name. This is a # requirement for some non-English language Excel patch levels. sorted_worksheets = @worksheets.sort_by{ |x| x.name } # Create the autofilter NAME records create_autofilter_name_records(sorted_worksheets) # Create the print area NAME records create_print_area_name_records(sorted_worksheets) # Create the print title NAME records create_print_title_name_records(sorted_worksheets) end def create_autofilter_name_records(sorted_worksheets) #:nodoc: sorted_worksheets.each do |worksheet| append(*worksheet.autofilter_name_record_short(true)) end end def create_print_area_name_records(sorted_worksheets) #:nodoc: sorted_worksheets.each do |worksheet| append(*worksheet.print_area_name_record_short) end end def create_print_title_name_records(sorted_worksheets) #:nodoc: sorted_worksheets.each do |worksheet| # Determine if row + col, row, col or nothing has been defined # and write the appropriate record # if worksheet.title_range.row_min && worksheet.title_range.col_min # Row and column titles have been defined. # Row title has been defined. append(*worksheet.print_title_name_record_long) elsif worksheet.title_range.row_min # Row title has been defined. append(*worksheet.print_title_name_record_short) elsif worksheet.title_range.col_min # Column title has been defined. append(*worksheet.print_title_name_record_short) else # Nothing left to do end end end ############################################################################### ############################################################################### # # BIFF RECORDS # # # Write Excel BIFF WINDOW1 record. # def store_window1 #:nodoc: record = 0x003D # Record identifier length = 0x0012 # Number of bytes to follow x_pos = 0x0000 # Horizontal position of window y_pos = 0x0000 # Vertical position of window dx_win = 0x355C # Width of window dy_win = 0x30ED # Height of window grbit = 0x0038 # Option flags ctabsel = @worksheets.selected_count # Number of workbook tabs selected tab_ratio = 0x0258 # Tab to scrollbar ratio tab_cur = @worksheets.activesheet_index # Active worksheet tab_first = @worksheets.firstsheet_index # 1st displayed worksheet header = [record, length].pack("vv") data = [ x_pos, y_pos, dx_win, dy_win, grbit, tab_cur, tab_first, ctabsel, tab_ratio ].pack("vvvvvvvvv") append(header, data) end # # Writes Excel BIFF BOUNDSHEET record. # # sheetname # Worksheet name # offset # Location of worksheet BOF # type # Worksheet type # hidden # Worksheet hidden flag # encoding # Sheet name encoding # def store_boundsheet(sheet) #:nodoc: append(sheet.boundsheet) end # # Write Excel BIFF STYLE records. # # type # Built-in style # xf_index # Index to style XF # def store_style(type, xf_index) #:nodoc: record = 0x0293 # Record identifier length = 0x0004 # Bytes to follow level = 0xff # Outline style level xf_index |= 0x8000 # Add flag to indicate built-in style. header = [record, length].pack("vv") data = [xf_index, type, level].pack("vCC") append(header, data) end # # Writes Excel FORMAT record for non "built-in" numerical formats. # # format # Custom format string # ifmt # Format index code # encoding # Char encoding for format string # def store_num_format(format, ifmt, encoding) #:nodoc: format = format.to_s unless format.respond_to?(:to_str) record = 0x041E # Record identifier # length # Number of bytes to follow # Char length of format string cch = format.bytesize ruby_19 { format = convert_to_ascii_if_ascii(format) } # Handle utf8 strings if is_utf8?(format) format = utf8_to_16be(format) encoding = 1 cch = format.bytesize end # Handle Unicode format strings. if encoding == 1 raise "Uneven number of bytes in Unicode font name" if cch % 2 != 0 cch /= 2 if encoding != 0 format = utf16be_to_16le(format) end =begin # Special case to handle Euro symbol, 0x80, in non-Unicode strings. if encoding == 0 and format =~ /\x80/ format = format.unpack('C*').pack('v*') format.gsub!(/\x80\x00/, "\xAC\x20") encoding = 1 end =end length = 0x05 + format.bytesize header = [record, length].pack("vv") data = [ifmt, cch, encoding].pack("vvC") append(header, data, format) end # # Write Excel 1904 record to indicate the date system in use. # def store_1904 #:nodoc: record = 0x0022 # Record identifier length = 0x0002 # Bytes to follow f1904 = @date_1904 ? 1 : 0 # Flag for 1904 date system header = [record, length].pack("vv") data = [f1904].pack("v") append(header, data) end # # Write BIFF record SUPBOOK to indicate that the workbook contains external # references, in our case, formula, print area and print title refs. # def store_supbook #:nodoc: record = 0x01AE # Record identifier length = 0x0004 # Number of bytes to follow tabs = @worksheets.size # Number of worksheets virt_path = 0x0401 # Encoded workbook filename header = [record, length].pack("vv") data = [tabs, virt_path].pack("vv") append(header, data) end # # Writes the Excel BIFF EXTERNSHEET record. These references are used by # formulas. TODO NAME record is required to define the print area and the # repeat rows and columns. # def store_externsheet # :nodoc: record = 0x0017 # Record identifier # Get the external refs ext = @ext_refs.keys.sort # Change the external refs from stringified "1:1" to [1, 1] ext.map! {|e| e.split(/:/).map! {|v| v.to_i} } cxti = ext.size # Number of Excel XTI structures rgxti = '' # Array of XTI structures # Write the XTI structs ext.each do |e| rgxti += [0, e[0], e[1]].pack("vvv") end data = [cxti].pack("v") + rgxti header = [record, data.bytesize].pack("vv") append(header, data) end # # Store the NAME record used for storing the print area, repeat rows, repeat # columns, autofilters and defined names. # # TODO. This is a more generic version that will replace store_name_short() # and store_name_long(). # def store_name(name, encoding, sheet_index, formula) # :nodoc: ruby_19 { formula = convert_to_ascii_if_ascii(formula) } record = 0x0018 # Record identifier text_length = name.bytesize formula_length = formula.bytesize # UTF-16 string length is in characters not bytes. text_length /= 2 if encoding != 0 grbit = 0x0000 # Option flags shortcut = 0x00 # Keyboard shortcut ixals = 0x0000 # Unused index. menu_length = 0x00 # Length of cust menu text desc_length = 0x00 # Length of description text help_length = 0x00 # Length of help topic text status_length = 0x00 # Length of status bar text # Set grbit built-in flag and the hidden flag for autofilters. if text_length == 1 grbit = 0x0020 if name.ord == 0x06 # Print area grbit = 0x0020 if name.ord == 0x07 # Print titles grbit = 0x0021 if name.ord == 0x0D # Autofilter end data = [grbit].pack("v") data += [shortcut].pack("C") data += [text_length].pack("C") data += [formula_length].pack("v") data += [ixals].pack("v") data += [sheet_index].pack("v") data += [menu_length].pack("C") data += [desc_length].pack("C") data += [help_length].pack("C") data += [status_length].pack("C") data += [encoding].pack("C") data += name data += formula header = [record, data.bytesize].pack("vv") append(header, data) end # # Stores the PALETTE biff record. # def store_palette #:nodoc: record = 0x0092 # Record identifier length = 2 + 4 * @palette.size # Number of bytes to follow ccv = @palette.size # Number of RGB values to follow data = '' # The RGB data # Pack the RGB data @palette.each do |p| data += p.pack('CCCC') end header = [record, length, ccv].pack("vvv") append(header, data) end # # Stores the CODEPAGE biff record. # def store_codepage #:nodoc: record = 0x0042 # Record identifier length = 0x0002 # Number of bytes to follow cv = @codepage # The code page store_common(record, length, cv) end # # Stores the COUNTRY biff record. # def store_country #:nodoc: record = 0x008C # Record identifier length = 0x0004 # Number of bytes to follow country_default = @country country_win_ini = @country store_common(record, length, country_default, country_win_ini) end # # Stores the HIDEOBJ biff record. # def store_hideobj #:nodoc: record = 0x008D # Record identifier length = 0x0002 # Number of bytes to follow hide = @hideobj ? 1 : 0 # Option to hide objects store_common(record, length, hide) end def store_common(record, length, *data) #:nodoc: header = [record, length].pack("vv") add_data = [*data].pack("v*") append(header, add_data) end # # We need to calculate the space required by the SUPBOOK, EXTERNSHEET and NAME # records so that it can be added to the BOUNDSHEET offsets. # def calculate_extern_sizes # :nodoc: ext_refs = @parser.get_ext_sheets length = 0 index = 0 unless defined_names.empty? index = 0 key = "#{index}:#{index}" add_ext_refs(ext_refs, key) unless ext_refs.has_key?(key) end defined_names.each do |defined_name| length += 19 + defined_name[:name].bytesize + defined_name[:formula].bytesize end @worksheets.each do |worksheet| key = "#{index}:#{index}" index += 1 # Add area NAME records # if worksheet.print_range.row_min add_ext_refs(ext_refs, key) unless ext_refs[key] length += 31 end # Add title NAME records # if worksheet.title_range.row_min && worksheet.title_range.col_min add_ext_refs(ext_refs, key) unless ext_refs[key] length += 46 elsif worksheet.title_range.row_min || worksheet.title_range.col_min add_ext_refs(ext_refs, key) unless ext_refs[key] length += 31 else # TODO, may need this later. end # Add Autofilter NAME records # unless worksheet.filter_count == 0 add_ext_refs(ext_refs, key) unless ext_refs[key] length += 31 end end # Update the ref counts. ext_ref_count = ext_refs.keys.size @ext_refs = ext_refs # If there are no external refs then we don't write, SUPBOOK, EXTERNSHEET # and NAME. Therefore the length is 0. return length = 0 if ext_ref_count == 0 # The SUPBOOK record is 8 bytes length += 8 # The EXTERNSHEET record is 6 bytes + 6 bytes for each external ref length += 6 * (1 + ext_ref_count) length end def add_ext_refs(ext_refs, key) #:nodoc: ext_refs[key] = ext_refs.keys.size end # # Handling of the SST continue blocks is complicated by the need to include an # additional continuation byte depending on whether the string is split between # blocks or whether it starts at the beginning of the block. (There are also # additional complications that will arise later when/if Rich Strings are # supported). As such we cannot use the simple CONTINUE mechanism provided by # the add_continue() method in BIFFwriter.pm. Thus we have to make two passes # through the strings data. The first is to calculate the required block sizes # and the second, in store_shared_strings(), is to write the actual strings. # The first pass through the data is also used to calculate the size of the SST # and CONTINUE records for use in setting the BOUNDSHEET record offsets. The # downside of this is that the same algorithm repeated in store_shared_strings. # def calculate_shared_string_sizes #:nodoc: str_block_sizes = @shared_string_table.block_sizes # Calculate the total length of the SST and associated CONTINUEs (if any). # The SST record will have a length even if it contains no strings. # This length is required to set the offsets in the BOUNDSHEET records since # they must be written before the SST records # # when array = [a, b, c] # array not empty? # length = 12 + a + 4 + b + 4 + c = 12 + a + b + c + 4 * (array.size - 1) # length = str_block_sizes.inject(12){|result, item| result + item} length += 4 * (str_block_sizes.size - 1) unless str_block_sizes.empty? length end def self.split_string_setup(encoding, split_string, continue_limit, written, continue) #:nodoc: # We need to avoid the case where a string is continued in the first # n bytes that contain the string header information. header_length = 3 # Min string + header size -1 space_remaining = continue_limit - written - continue # Unicode data should only be split on char (2 byte) boundaries. # Therefore, in some cases we need to reduce the amount of available # space by 1 byte to ensure the correct alignment. align = 0 # Only applies to Unicode strings if encoding == 1 # Min string + header size -1 header_length = 4 if space_remaining > header_length # String contains 3 byte header => split on odd boundary if split_string == 0 and space_remaining % 2 != 1 space_remaining -= 1 align = 1 # Split section without header => split on even boundary elsif split_string != 0 and space_remaining % 2 == 1 space_remaining -= 1 align = 1 end split_string = 1 end end [header_length, space_remaining, align, split_string] end def_delegator self, :split_string_setup # # Write all of the workbooks strings into an indexed array. # # See the comments in calculate_shared_string_sizes() for more information. # # We also use this routine to record the offsets required by the EXTSST table. # In order to do this we first identify the first string in an EXTSST bucket # and then store its global and local offset within the SST table. The offset # occurs wherever the start of the bucket string is written out via append(). # def store_shared_strings #:nodoc: record = 0x00FC # Record identifier length = 0x0008 # Number of bytes to follow total = 0x0000 # Iterate through the strings to calculate the CONTINUE block sizes continue_limit = 8208 block_length = 0 written = 0 continue = 0 # The SST and CONTINUE block sizes have been pre-calculated by # calculate_shared_string_sizes() block_sizes = @shared_string_table.block_sizes # The SST record is required even if it contains no strings. Thus we will # always have a length # if block_sizes.size != 0 length = 8 + block_sizes.shift else # No strings length = 8 end # Initialise variables used to track EXTSST bucket offsets. extsst_str_num = -1 sst_block_start = @datasize # Write the SST block header information header = [record, length].pack("vv") data = [@shared_string_table.str_total, @shared_string_table.str_unique].pack("VV") append(header, data) # Iterate through the strings and write them out return if @shared_string_table.strings.empty? @shared_string_table.strings.each do |string| string_length = string.bytesize # Check if the string is at the start of a EXTSST bucket. extsst_str_num += 1 # Used to track EXTSST bucket offsets. bucket_string = (extsst_str_num % @extsst_bucket_size == 0) # Block length is the total length of the strings that will be # written out in a single SST or CONTINUE block. # block_length += string_length # We can write the string if it doesn't cross a CONTINUE boundary if block_length < continue_limit # Store location of EXTSST bucket string. if bucket_string @extsst_offsets.push([@datasize, @datasize - sst_block_start]) bucket_string = false end append(string) written += string_length next end # Deal with the cases where the next string to be written will exceed # the CONTINUE boundary. If the string is very long it may need to be # written in more than one CONTINUE record. encoding = string.unpack("xx C")[0] split_string = 0 while block_length >= continue_limit header_length, space_remaining, align, split_string = split_string_setup(encoding, split_string, continue_limit, written, continue) if space_remaining > header_length # Write as much as possible of the string in the current block tmp = string[0, space_remaining] # Store location of EXTSST bucket string. if bucket_string @extsst_offsets.push([@datasize, @datasize - sst_block_start]) bucket_string = false end append(tmp) # The remainder will be written in the next block(s) string = string[space_remaining .. string.length-1] # Reduce the current block length by the amount written block_length -= continue_limit -continue -align # If the current string was split then the next CONTINUE block # should have the string continue flag (grbit) set unless the # split string fits exactly into the remaining space. # if block_length > 0 continue = 1 else continue = 0 end else # Not enough space to start the string in the current block block_length -= continue_limit -space_remaining -continue continue = 0 end # Write the CONTINUE block header if block_sizes.size != 0 sst_block_start= @datasize # Reset EXTSST offset. record = 0x003C length = block_sizes.shift header = [record, length].pack("vv") header += [encoding].pack("C") if continue != 0 append(header) end # If the string (or substr) is small enough we can write it in the # new CONTINUE block. Else, go through the loop again to write it in # one or more CONTINUE blocks # if block_length < continue_limit # Store location of EXTSST bucket string. if bucket_string @extsst_offsets.push([@datasize, @datasize - sst_block_start]) bucket_string = false end append(string) written = block_length else written = 0 end end end end # # The number of buckets used in the EXTSST is between 0 and 128. The number of # strings per bucket (bucket size) has a minimum value of 8 and a theoretical # maximum of 2^16. For "number of strings" < 1024 there is a constant bucket # size of 8. The following algorithm generates the same size/bucket ratio # as Excel. # def calculate_extsst_size(str_unique) #:nodoc: unique_strings = str_unique if unique_strings < 1024 bucket_size = 8 else bucket_size = 1 + Integer(unique_strings / 128.0) end buckets = Integer((unique_strings + bucket_size -1) / Float(bucket_size)) @extsst_buckets = buckets @extsst_bucket_size = bucket_size 6 + 8 * buckets end # # Write EXTSST table using the offsets calculated in store_shared_strings(). # def store_extsst #:nodoc: offsets = @extsst_offsets bucket_size = @extsst_bucket_size record = 0x00FF # Record identifier length = 2 + 8 * offsets.size # Bytes to follow header = [record, length].pack('vv') data = [bucket_size].pack('v') offsets.each do |offset| data += [offset[0], offset[1], 0].pack('Vvv') end append(header, data) end # # Methods related to comments and MSO objects. # # # Write the MSODRAWINGGROUP record that keeps track of the Escher drawing # objects in the file such as images, comments and filters. # def add_mso_drawing_group #:nodoc: return unless @mso_size != 0 record = 0x00EB # Record identifier length = 0x0000 # Number of bytes to follow data = store_mso_dgg_container data += store_mso_dgg(*@mso_clusters) data += store_mso_bstore_container @images_data.each do |image| data += store_mso_images(image) end data += store_mso_opt data += store_mso_split_menu_colors length = data.bytesize header = [record, length].pack("vv") add_mso_drawing_group_continue(header + data) header + data # For testing only. end # # See first BIFFwriter#add_continue() method. # # Add specialised CONTINUE headers to large MSODRAWINGGROUP data block. # We use the Excel 97 max block size of 8228 - 4 bytes for the header = 8224. # # The structure depends on the size of the data block: # # Case 1: <= 8224 bytes 1 MSODRAWINGGROUP # Case 2: <= 2*8224 bytes 1 MSODRAWINGGROUP + 1 CONTINUE # Case 3: > 2*8224 bytes 2 MSODRAWINGGROUP + n CONTINUE # def add_mso_drawing_group_continue(data) #:nodoc: limit = 8228 -4 mso_group = 0x00EB # Record identifier continue = 0x003C # Record identifier block_count = 1 # Ignore the base class add_continue() method. @ignore_continue = true # Case 1 above. Just return the data as it is. if data.bytesize <= limit append(data) return end # Change length field of the first MSODRAWINGGROUP block. Case 2 and 3. tmp, data = devide_string(data, limit + 4) tmp[2, 2] = [limit].pack('v') append(tmp) # Add MSODRAWINGGROUP and CONTINUE blocks for Case 3 above. while data.bytesize > limit if block_count == 1 # Add extra MSODRAWINGGROUP block header. header = [mso_group, limit].pack("vv") block_count += 1 else # Add normal CONTINUE header. header = [continue, limit].pack("vv") end tmp, data = devide_string(data, limit) append(header, tmp) end # Last CONTINUE block for remaining data. Case 2 and 3 above. header = [continue, data.bytesize].pack("vv") append(header, data) # Turn the base class add_continue() method back on. @ignore_continue = false end def devide_string(string, nth) #:nodoc: first_string = string[0, nth] latter_string = string[nth, string.size - nth] [first_string, latter_string] end # # Write the Escher DggContainer record that is part of MSODRAWINGGROUP. # def store_mso_dgg_container #:nodoc: type = 0xF000 version = 15 instance = 0 data = '' length = @mso_size -12 # -4 (biff header) -8 (for this). add_mso_generic(type, version, instance, data, length) end # # Write the Escher Dgg record that is part of MSODRAWINGGROUP. # def store_mso_dgg(max_spid, num_clusters, shapes_saved, drawings_saved, clusters) #:nodoc: type = 0xF006 version = 0 instance = 0 data = '' length = nil # Calculate automatically. data = [max_spid, num_clusters, shapes_saved, drawings_saved].pack("VVVV") clusters.each do |aref| drawing_id = aref[0] shape_ids_used = aref[1] data += [drawing_id, shape_ids_used].pack("VV") end add_mso_generic(type, version, instance, data, length) end # # Write the Escher BstoreContainer record that is part of MSODRAWINGGROUP. # def store_mso_bstore_container #:nodoc: return '' if @images_size == 0 type = 0xF001 version = 15 instance = @images_data.size # Number of images. data = '' length = @images_size +8 *instance add_mso_generic(type, version, instance, data, length) end # # Write the Escher BstoreContainer record that is part of MSODRAWINGGROUP. # def store_mso_images(image) blip_store_entry = store_mso_blip_store_entry( image.ref_count, image.type, image.size, image.checksum1 ) blip = store_mso_blip( image.type, image.data, image.size, image.checksum1, image.checksum2 ) blip_store_entry + blip end # # Write the Escher BlipStoreEntry record that is part of MSODRAWINGGROUP. # def store_mso_blip_store_entry(ref_count, image_type, size, checksum1) #:nodoc: type = 0xF007 version = 2 instance = image_type length = size +61 data = [image_type].pack('C') + # Win32 [image_type].pack('C') + # Mac [checksum1].pack('H*') + # Uid checksum [0xFF].pack('v') + # Tag [size +25].pack('V') + # Next Blip size [ref_count].pack('V') + # Image ref count [0x00000000].pack('V') + # File offset [0x00].pack('C') + # Usage [0x00].pack('C') + # Name length [0x00].pack('C') + # Unused [0x00].pack('C') # Unused add_mso_generic(type, version, instance, data, length) end # # Write the Escher Blip record that is part of MSODRAWINGGROUP. # def store_mso_blip(image_type, image_data, size, checksum1, checksum2) #:nodoc: instance = 0x046A if image_type == 5 # JPG instance = 0x06E0 if image_type == 6 # PNG instance = 0x07A9 if image_type == 7 # BMP # BMPs contain an extra checksum for the stripped data. if image_type == 7 checksum1 = checksum2 + checksum1 end type = 0xF018 + image_type version = 0x0000 length = size +17 data = [checksum1].pack('H*') + # Uid checksum [0xFF].pack('C') + # Tag image_data # Image add_mso_generic(type, version, instance, data, length) end # # Write the Escher Opt record that is part of MSODRAWINGGROUP. # def store_mso_opt #:nodoc: type = 0xF00B version = 3 instance = 3 data = '' length = 18 data = ['BF0008000800810109000008C0014000'+'0008'].pack("H*") add_mso_generic(type, version, instance, data, length) end # # Write the Escher SplitMenuColors record that is part of MSODRAWINGGROUP. # def store_mso_split_menu_colors #:nodoc: type = 0xF11E version = 0 instance = 4 data = '' length = 16 data = ['0D0000080C00000817000008F7000010'].pack("H*") add_mso_generic(type, version, instance, data, length) end def cleanup #:nodoc: super sheets.each { |sheet| sheet.cleanup } end def add_doc_properties @add_doc_properties ||= false end def defined_names @defined_names end end