First there isn’t too much to get this ActiveX controller up in running in the first place. There are great examples here that take you 95% of the way towards getting these up and running. A few little tricks we learned when setting up the javascript portion of the code are as follows:

• To set the page size use the following method (the example sets it to letter):

        csxi.SetTwainLayout(0,8.5,0,11)

• Some scanners do not reset to their defaults after a custom scan. You need to make sure you manually set all default settings before scanning. A few you may want to set:

        csxi.UseTwainInterface=false; //this makes sure that you are not prompted to change settings
        csxi.TwainAutoBright = true;
        csxi.TwainAutoDeskew = true;

• When beginning a multipage scan you must run the following three methods:
  

        csxi.TwainMultiImage = true;
        csxi.UseADF = true;
        csxi.ClearPDF();

One other fun thing we can do with ChestySoft’s TwainX controller is upload the captured data directly to the server. To do this in the javascript you need to do the following:

      Success = csxi.PostImage(url, file_name, param_name, graphics_format);
      if (Success) {
        //what to do when success
      } else {
        //what to do if error - here are recommendations:
        csxi.SaveToFile(path_on_desktop) //write data to desktop if you saved as a graphic; 
        csxi.WritePDF(path_on_desktop) //write data to desktop if you saved as a pdf; 
      }

Some notes about the preceding code. url a fully qualified url (including the ‘http://’). file_name is what will be included as original_filename when you are reading data on the server side. graphics_format is a enumeration that can be found here.

And the best thing is after you click on the button that runs your scan the information uploaded is the same as a standard file upload so you don’t have to do anything strange at all in ruby.

In the project that I wrote this for we began by creating a wrapper class for the PDFTK gem mentioned earlier. The basic shell of the method we will be using accepts a list of files and a a title for the new pdf and begins and ends by creating and removing temp directories respectively.

class PdfTool< PDF::Toolkit
  def self.concat_and_make_table_of_contents(title, files)
    require 'pdf/writer'
    begin
      tmpdir = make_temp('')
      FileUtils.mkdir(tmpdir)
 
       #the rest of the code is going here   
 
    rescue => error
      raise error
    ensure
      FileUtils.rm(temppath)
    end
 
  end
end

Following this we are going to have set up PDF::Writer for creating the table of contents. Unfortunately PDF::Writer is a bit messy to get going, but we are only going to be creating a table of contents with the simplest format possible so it will not be too bad. Of course if you are not going to want this hard coded, we could easily rewrite the concat_and_make_table_of_contents so that it takes a hash of formatting variables. Here is the set up of PDF:Writer as well printing of the title.

      @text_font = "Times-Roman"
      @title_font_size = 17
      @title_vertical_spacing = 15
      @page_font_size = 12
      @page_vertical_spacing = 8
 
      print_pdf = PDF::Writer.new(:paper => "A4")
      print_pdf.margins_pt(36)
      @top_heading_font_position = 10
 
      print_pdf.select_font @text_font
      print_pdf.text("<b>#{title}</b>", :font_size => @title_font_size,:justification => :center,:left => @top_heading_font_position)
      print_pdf.move_pointer(@title_vertical_spacing)

Next we need to go through the files and generate the table of contents. We will have a loop to check that all of the files in the array exist and are PDFs (though this will need to change if you decide to add in html, etc conversion). Then we are going to start assuming the first page of the first document in the list is page 1 (if you want to include the table of contents in the page count you will mostly likely have to generate the table of contents once, then figure out how many pages is its then regenerate it with the offset – but we are simplifying this for this example). Following that we are going to loop though all of the files, determine the title from the metadata and print the title and the page number for each page. This will finish up by saving the table of contents to a temp file. (Note: don’t be confused we are keeping track of two pdf variables – pdf which corresponds to PDFTK instances and print_pdf which corresponds to PDF::Writer instances).

      files = files.delete_if {|f| !File.exists?(f) || File.mime_type?(f) != 'application/pdf'}
      current_page=1
      files.each do |f|
        pdf = open(f)
        page_title = ((pdf[:Title] || pdf[:File]) || File.basename(f))
        print_pdf.text("#{page_title} - #{current_page}", :font_size => @page_font_size,:justification => :left)
        print_pdf.move_pointer(@page_vertical_spacing)
        current_page+= pdf.pages
      end
 
      print_pdf.save_as(File.join(tmpdir,'toc.pdf'))

You may have noticed one method in the previous code that needs some flushing out. PDFTK provides accessors for all metadata that can be found in the pdf, you simply pass a symbol or a string to the [] method to retrieve it. Furthermore you can use PDFTK to access the number of pages in the file by simply calling pages.

For the last step we are going to concatenate all of the files that were passed in the array with the table of contents. Again PDFTK will come in handy here. There is a class method pdftk which will accept any commands that PDFTK will run as an array. So all we need to do is have the PDFTK invoke the concat method. Following that we are just going to read the data for the generated file and pass that back before we start rescuing and ensuring code. This portion is as follows:

      command = [File.join(tmpdir,'toc.pdf')] + files + ['cat','output',File.join(tmpdir, 'outfile.pdf')]
      raise IOError, "Unknown PDFTK Error command: pdftk #{command.join(' ')}" unless pdftk(*command)
 
      data = nil
      File.open(File.join(tmpdir, 'outfile.pdf'), 'r') { |f| data = f.read }
 
      return data

So now we have a simple method for concatenating and creating a table of contents for several PDF files.