rhodes 3.3.3.beta.4 → 3.3.3

data/lib/extensions/pdf-writer/pdf/techbook.rb

@@ -0,0 +1,901 @@
+#! /usr/bin/env ruby
+#--
+# PDF::Writer for Ruby.
+#   http://rubyforge.org/projects/ruby-pdf/
+#   Copyright 2003 - 2005 Austin Ziegler.
+#
+#   Licensed under a MIT-style licence. See LICENCE in the main distribution
+#   for full licensing information.
+#
+# $Id: techbook.rb 134 2005-08-25 03:38:06Z austin $
+#++
+require 'pdf/simpletable'
+require 'pdf/charts/stddev'
+
+require 'cgi'
+require 'open-uri'
+
+begin
+  require 'progressbar'
+rescue LoadError
+  class ProgressBar #:nodoc:
+    def initialize(*args)
+    end
+    def method_missing(*args)
+    end
+  end
+end
+
+require 'optparse'
+require 'ostruct'
+
+  # = PDF::TechBook
+  # The TechBook class is a markup language interpreter. This will read a
+  # file containing the "TechBook" markukp, described below, and create a
+  # PDF document from it. This is intended as a complete document language,
+  # but it does have a number of limitations.
+  #
+  # The TechBook markup language and class are used to format the
+  # PDF::Writer manual, represented in the distrubtion by the file
+  # "manual.pwd".
+  #
+  # The TechBook markup language is *primarily* stream-oriented with
+  # awareness of lines. That is to say that the document will be read and
+  # generated from beginning to end in the order of the markup stream.
+  #
+  # == TechBook Markup
+  # TechBook markup is relatively simple. The simplest markup is no markup
+  # at all (flowed paragraphs). This means that two lines separated by a
+  # single line separator will be treaed as part of the same paragraph and
+  # formatted appropriately by PDF::Writer. Paragaphs are terminated by
+  # empty lines, valid line markup directives, or valid headings.
+  #
+  # Certain XML entitites will need to be escaped as they would in normal
+  # XML usage, that is, < must be written as <; > must be
+  # written as >; and & must be written as &.
+  #
+  # Comments, headings, and directives are line-oriented where the first
+  # mandatory character is in the first column of the document and take up
+  # the whole line. Styling and callback tags may appear anywhere in the
+  # text.
+  #
+  # === Comments
+  # Comments begin with the hash-mark ('#') at the beginning of the line.
+  # Comment lines are ignored.
+  #
+  # === Styling and Callback Tags
+  # Within normal, preserved, or code text, or in headings, HTML-like markup
+  # may be used for bold (<b>) and italic (<i>) text. TechBook
+  # supports standard PDF::Writer callback tags (<c:alink>, <c:ilink>,
+  # <C:bullet/>, and <C:disc/>) and adds two new ones (<r:xref/>,
+  # <C:tocdots/>).
+  #
+  # <tt>&lt;r:xref/></tt>::     Creates an internal document link to the
+  #                             named cross-reference destination. Works
+  #                             with the heading format (see below). See
+  #                             #tag_xref_replace for more information.
+  # <tt>&lt;C:tocdots/></tt>::  This is used internally to create and
+  #                             display a row of dots between a table of
+  #                             contents entry and the page number to which
+  #                             it refers. This is used internally by
+  #                             TechBook.
+  #
+  # === Directives
+  # Directives begin with a period ('.') and are followed by a letter
+  # ('a'..'z') and then any combination of word characters ('a'..'z',
+  # '0'..'9', and '_'). Directives are case-insensitive. A directive may
+  # have arguments; if there are arguments, they must follow the directive
+  # name after whitespace. After the arguments for a directive, if any, all
+  # other text is ignored and may be considered a comment.
+  #
+  # ==== <tt>.newpage [force]</tt>
+  # The <tt>.newpage</tt> directive starts a new page. If multicolumn mode
+  # is on, a new column will be started if the current column is not the
+  # last column. If the optional argument <tt>force</tt> follows the
+  # <tt>.newpage</tt> directive, a new page will be started even if
+  # multicolumn mode is on.
+  #
+  #   .newpage
+  #   .newpage force
+  #
+  # ==== <tt>.pre</tt>, <tt>.endpre</tt>
+  # The <tt>.pre</tt> and <tt>.endpre</tt> directives enclose a block of
+  # text with preserved newlines. This is similar to normal text, but the
+  # lines in the <tt>.pre</tt> block are not flowed together. This is useful
+  # for poetic forms or other text that must end when each line ends.
+  # <tt>.pre</tt> blocks may not be nested in any other formatting block.
+  # When an <tt>.endpre</tt> directive is encountered, the text format will
+  # be returned to normal (flowed text) mode.
+  #
+  #   .pre
+  #   The Way that can be told of is not the eternal Way;
+  #   The name that can be named is not the eternal name.
+  #   The Nameless is the origin of Heaven and Earth;
+  #   The Named is the mother of all things.
+  #   Therefore let there always be non-being,
+  #     so we may see their subtlety,
+  #   And let there always be being,
+  #     so we may see their outcome.
+  #   The two are the same,
+  #   But after they are produced,
+  #     they have different names.
+  #   .endpre
+  #
+  # ==== <tt>.code</tt>, <tt>.endcode</tt>
+  # The <tt>.code</tt> and <tt>.endcode</tt> directives enclose a block of
+  # text with preserved newlines. In addition, the font is changed from the
+  # normal #techbook_textfont to #techbook_codefont. The #techbook_codefont
+  # is normally a fixed pitched font and defaults to Courier. At the end of
+  # the code block, the text state is restored to its prior state, which
+  # will either be <tt>.pre</tt> or normal. 
+  #
+  #   .code
+  #   require 'pdf/writer'
+  #   PDF::Writer.prepress # US Letter, portrait, 1.3, prepress
+  #   .endcode
+  #
+  # ==== <tt>.blist</tt>, <tt>.endblist</tt>
+  # These directives enclose a bulleted list block. Lists may be nested
+  # within other text states. If lists are nested, each list will be
+  # appropriately indented. Each line in the list block will be treated as a
+  # single list item with a bullet inserted in front using either the
+  # <C:bullet/> or <C:disc/> callbacks. Nested lists are successively
+  # indented. <tt>.blist</tt> directives accept one optional argument, the
+  # name of the type of bullet callback desired (e.g., 'bullet' for
+  # <C:bullet/> and 'disc' for <C:disc/>).
+  #
+  #   .blist
+  #   Item 1
+  #   .blist disc
+  #   Item 1.1
+  #   .endblist
+  #   .endblist
+  #
+  # ==== <tt>.eval</tt>, <tt>.endeval</tt>
+  # With these directives, the block enclosed will collected and passed to
+  # Ruby's Kernel#eval. <tt>.eval</tt> blocks may be present within normal
+  # text, <tt>.pre</tt>, <tt>.code</tt>, and <tt>.blist</tt> blocks. No
+  # other block may be embedded within an <tt>.eval</tt> block.
+  #
+  #   .eval
+  #   puts "Hello"
+  #   .endeval
+  #
+  # ==== <tt>.columns</tt>
+  # Multi-column output is controlled with this directive, which accepts one
+  # or two parameters. The first parameter is mandatory and is either the
+  # number of columns (2 or more) or the word 'off' (turning off
+  # multi-column output). When starting multi-column output, a second
+  # parameter with the gutter size may be specified.
+  #
+  #   .columns 3
+  #   Column 1
+  #   .newpage
+  #   Column 2
+  #   .newpage
+  #   Column 3
+  #   .columns off
+  #
+  # ==== <tt>.toc</tt>
+  # This directive is used to tell TechBook to generate a table of contents
+  # after the first page (assumed to be a title page). If this is not
+  # present, then a table of contents will not be generated.
+  #
+  # ==== <tt>.author</tt>, <tt>.title</tt>, <tt>.subject</tt>, <tt>.keywords</tt>
+  # Sets values in the PDF information object. The arguments -- to the end
+  # of the line -- are used to populate the values.
+  #
+  # ==== <tt>.done</tt>
+  # Stops the processing of the document at this point.
+  #
+  # === Headings
+  # Headings begin with a number followed by the rest of the heading format.
+  # This format is "#<heading-text>" or "#<heading-text>xref_name". TechBook
+  # supports five levels of headings. Headings may include markup, but
+  # should not exceed a single line in size; those headings which have boxes
+  # as part of their layout are not currently configured to work with
+  # multiple lines of heading output. If an xref_name is specified, then the
+  # &lt;r:xref> tag can use this name to find the target for the heading. If
+  # xref_name is not specified, then the "name" associated with the heading
+  # is the index of the order of insertion. The xref_name is case sensitive.
+  #
+  #   1<Chapter>xChapter
+  #   2<Section>Section23
+  #   3<Subsection>
+  #   4<Subsection>
+  #   5<Subsection>
+  #
+  # ==== Heading Level 1
+  # First level headings are generally chapters. As such, the standard
+  # implementation of the heading level 1 method (#__heading1), will be
+  # rendered as "chapter#. heading-text" in centered white on a black
+  # background, at 26 point (H1_STYLE). First level headings are added to
+  # the table of contents.
+  #
+  # ==== Heading Level 2
+  # Second level headings are major sections in chapters. The headings are
+  # rendered by default as black on 80% grey, left-justified at 18 point
+  # (H2_STYLE). The text is unchanged (#__heading2). Second level headings
+  # are added to the table of contents.
+  #
+  # ==== Heading Level 3, 4, and 5
+  # The next three heading levels are used for varying sections within
+  # second level chapter sections. They are rendered by default in black on
+  # the background (there is no bar) at 18, 14, and 12 points, respectively
+  # (H3_STYLE, H4_STYLE, and H5_STYLE). Third level headings are bold-faced
+  # (#__heading3); fourth level headings are italicised (#__heading4), and
+  # fifth level headings are underlined (#__heading5).
+  #
+class PDF::TechBook < PDF::Writer
+  attr_accessor :table_of_contents
+  attr_accessor :chapter_number
+
+    # A stand-alone replacement callback that will return an internal link
+    # with either the name of the cross-reference or the page on which the
+    # cross-reference appears as the label. If the page number is not yet
+    # known (when the cross-referenced item has not yet been rendered, e.g.,
+    # forward-references), the label will be used in any case.
+    #
+    # The parameters are:
+    # name::  The name of the cross-reference.
+    # label:: Either +page+, +title+, or +text+. +page+ will <em>not</em> be
+    #         used for forward references; only +title+ or +text+ will be
+    #         used.
+    # text::  Required if +label+ has a value of +text+. Ignored if +label+
+    #         is +title+, optional if +label+ is +page+. This value will be
+    #         used as the display text for the internal link. +text+
+    #         takes precedence over +title+ if +label+ is +page+.
+  class TagXref
+    def self.[](pdf, params)
+      name  = params["name"]
+      item  = params["label"]
+      text  = params["text"]
+
+      xref = pdf.xref_table[name]
+      if xref
+        case item
+        when 'page'
+          label = xref[:page]
+          if text.nil? or text.empty?
+            label ||= xref[:title]
+          else
+            label ||= text
+          end
+        when 'title'
+          label = xref[:title]
+        when 'text'
+          label = text
+        end
+
+        "<c:ilink dest='#{xref[:xref]}'>#{label}</c:ilink>"
+      else
+        warn PDF::Writer::Lang[:techbook_unknown_xref] % [ name ]
+        PDF::Writer::Lang[:techbook_unknown_xref] % [ name ]
+      end
+    end
+  end
+  PDF::Writer::TAGS[:replace]["xref"] = PDF::TechBook::TagXref
+
+    # A stand-alone callback that draws a dotted line over to the right and
+    # appends a page number. The info[:params] will be like a standard XML
+    # tag with three named parameters:
+    #
+    # level:: The table of contents level that corresponds to a particular
+    #         style. In the current TechBook implementation, there are only
+    #         two levels. Level 1 uses a 16 point font and #level1_style;
+    #         level 2 uses a 12 point font and #level2_style.
+    # page::  The page number that is to be printed.
+    # xref::  The target destination that will be used as a link.
+    #
+    # All parameters are required.
+  class TagTocDots
+    DEFAULT_L1_STYLE = {
+      :width      => 1,
+      :cap        => :round,
+      :dash       => { :pattern => [ 1, 3 ], :phase => 1 },
+      :font_size  => 16
+    }
+
+    DEFAULT_L2_STYLE = {
+      :width      => 1,
+      :cap        => :round,
+      :dash       => { :pattern => [ 1, 5 ], :phase => 1 },
+      :font_size  => 12
+    }
+
+    class << self
+        # Controls the level 1 style.
+      attr_accessor :level1_style
+        # Controls the level 2 style.
+      attr_accessor :level2_style
+
+      def [](pdf, info)
+        if @level1_style.nil?
+          @level1_style = sh = DEFAULT_L1_STYLE
+          ss      = PDF::Writer::StrokeStyle.new(sh[:width])
+          ss.cap  = sh[:cap] if sh[:cap]
+          ss.dash = sh[:dash] if sh[:dash]
+          @_level1_style = ss
+        end
+        if @level2_style.nil?
+          @level2_style = sh = DEFAULT_L2_STYLE
+          ss      = PDF::Writer::StrokeStyle.new(sh[:width])
+          ss.cap  = sh[:cap] if sh[:cap]
+          ss.dash = sh[:dash] if sh[:dash]
+          @_level2_style = ss
+        end
+
+        level = info[:params]["level"]
+        page  = info[:params]["page"]
+        xref  = info[:params]["xref"]
+
+        xpos = 520
+
+        pdf.save_state
+        case level
+        when "1"
+          pdf.stroke_style @_level1_style
+          size = @level1_style[:font_size]
+        when "2"
+          pdf.stroke_style @_level2_style
+          size = @level2_style[:font_size]
+        end
+
+        page = "<c:ilink dest='#{xref}'>#{page}</c:ilink>" if xref
+
+        pdf.line(xpos, info[:y], info[:x] + 5, info[:y]).stroke
+        pdf.restore_state
+        pdf.add_text(xpos + 5, info[:y], page, size)
+      end
+    end
+  end
+  PDF::Writer::TAGS[:single]["tocdots"] = PDF::TechBook::TagTocDots
+
+  attr_reader :xref_table
+  def __build_xref_table(data)
+    headings = data.grep(HEADING_FORMAT_RE)
+
+    @xref_table = {}
+
+    headings.each_with_index do |text, idx|
+      level, label, name = HEADING_FORMAT_RE.match(text).captures
+
+      xref = "xref#{idx}"
+
+      name ||= idx.to_s
+      @xref_table[name] = {
+        :title  => __send__("__heading#{level}", label),
+        :page   => nil,
+        :level  => level.to_i,
+        :xref   => xref
+      }
+    end
+  end
+  private :__build_xref_table
+
+  def __render_paragraph
+    unless @techbook_para.empty?
+      techbook_text(@techbook_para.squeeze(" "))
+      @techbook_para.replace ""
+    end
+  end
+  private :__render_paragraph
+
+  LINE_DIRECTIVE_RE = %r{^\.([a-z]\w+)(?:$|\s+(.*)$)}io #:nodoc:
+
+  def techbook_find_directive(line)
+    directive = nil
+    arguments = nil
+    dmatch = LINE_DIRECTIVE_RE.match(line)
+    if dmatch
+      directive = dmatch.captures[0].downcase.chomp
+      arguments = dmatch.captures[1]
+    end
+    [directive, arguments]
+  end
+  private :techbook_find_directive
+
+  H1_STYLE = {
+    :background     => Color::RGB::Black,
+    :foreground     => Color::RGB::White,
+    :justification  => :center,
+    :font_size      => 26,
+    :bar            => true
+  }
+  H2_STYLE = {
+    :background     => Color::RGB::Grey80,
+    :foreground     => Color::RGB::Black,
+    :justification  => :left,
+    :font_size      => 18,
+    :bar            => true
+  }
+  H3_STYLE = {
+    :background     => Color::RGB::White,
+    :foreground     => Color::RGB::Black,
+    :justification  => :left,
+    :font_size      => 18,
+    :bar            => false
+  }
+  H4_STYLE = {
+    :background     => Color::RGB::White,
+    :foreground     => Color::RGB::Black,
+    :justification  => :left,
+    :font_size      => 14,
+    :bar            => false
+  }
+  H5_STYLE = {
+    :background     => Color::RGB::White,
+    :foreground     => Color::RGB::Black,
+    :justification  => :left,
+    :font_size      => 12,
+    :bar            => false
+  }
+  def __heading1(heading)
+    @chapter_number ||= 0
+    @chapter_number = @chapter_number.succ
+    "#{chapter_number}. #{heading}"
+  end
+  def __heading2(heading)
+    heading
+  end
+  def __heading3(heading)
+    "<b>#{heading}</b>"
+  end
+  def __heading4(heading)
+    "<i>#{heading}</i>"
+  end
+  def __heading5(heading)
+    "<c:uline>#{heading}</c:uline>"
+  end
+
+  HEADING_FORMAT_RE = %r{^([\d])<(.*)>([a-z\w]+)?$}o #:nodoc:
+
+  def techbook_heading(line)
+    head = HEADING_FORMAT_RE.match(line)
+    if head
+      __render_paragraph
+
+      @heading_num ||= -1
+      @heading_num += 1
+
+      level, heading, name = head.captures
+      level = level.to_i
+
+      name ||= @heading_num.to_s
+      heading = @xref_table[name]
+
+      style   = self.class.const_get("H#{level}_STYLE")
+
+      start_transaction(:heading_level)
+      ok = false
+
+      loop do # while not ok
+        break if ok
+        this_page = pageset.size
+
+        save_state
+
+        if style[:bar]
+          fill_color style[:background]
+          fh = font_height(style[:font_size]) * 1.01
+          fd = font_descender(style[:font_size]) * 1.01
+          x = absolute_left_margin
+          w = absolute_right_margin - absolute_left_margin
+          rectangle(x, y - fh + fd, w, fh).fill
+        end
+
+        fill_color style[:foreground]
+        text(heading[:title], :font_size => style[:font_size],
+             :justification => style[:justification])
+
+        restore_state
+
+        if (pageset.size == this_page)
+          commit_transaction(:heading_level)
+          ok = true
+        else
+            # We have moved onto a new page. This is bad, as the background
+            # colour will be on the old one.
+          rewind_transaction(:heading_level)
+          start_new_page
+        end
+      end
+
+      heading[:page] = which_page_number(current_page_number)
+
+      case level
+      when 1, 2
+        @table_of_contents << heading
+      end
+
+      add_destination(heading[:xref], 'FitH', @y + font_height(style[:font_size]))
+    end
+    head
+  end
+  private :techbook_heading
+
+  def techbook_parse(document, progress = nil)
+    @table_of_contents = []
+
+    @toc_title          = "Table of Contents"
+    @gen_toc            = false
+    @techbook_code      = ""
+    @techbook_para      = ""
+    @techbook_fontsize  = 12
+    @techbook_textopt   = { :justification => :full }
+    @techbook_lastmode  = @techbook_mode = :normal
+
+    @techbook_textfont  = "Times-Roman"
+    @techbook_codefont  = "Courier"
+
+    @blist_info         = []
+
+    @techbook_line__    = 0
+
+    __build_xref_table(document)
+
+    document.each do |line|
+    begin
+      progress.inc if progress
+      @techbook_line__ += 1
+
+      next if line =~ %r{^#}o
+
+      directive, args = techbook_find_directive(line)
+      if directive
+          # Just try to call the method/directive. It will be far more
+          # common to *find* the method than not to.
+        res = __send__("techbook_directive_#{directive}", args) rescue nil
+        break if :break == res 
+        next
+      end
+
+      case @techbook_mode
+      when :eval
+        @techbook_code << line << "\n"
+        next
+      when :code
+        techbook_text(line)
+        next
+      when :blist
+        line = "<C:#{@blist_info[-1][:style]}/>#{line}"
+        techbook_text(line)
+        next
+      end
+
+      next if techbook_heading(line)
+
+      if :preserved == @techbook_mode
+        techbook_text(line)
+        next
+      end
+
+      line.chomp!
+
+      if line.empty?
+        __render_paragraph
+        techbook_text("\n")
+      else
+        @techbook_para << " " unless @techbook_para.empty?
+        @techbook_para << line
+      end
+    rescue Exception => ex
+      $stderr.puts PDF::Writer::Lang[:techbook_exception] % [ ex, @techbook_line ]
+      raise
+    end
+    end
+  end
+
+  def techbook_toc(progress = nil)
+    insert_mode :on
+    insert_position :after
+    insert_page 1
+    start_new_page
+
+    style = H1_STYLE
+    save_state
+
+    if style[:bar]
+      fill_color    style[:background]
+      fh = font_height(style[:font_size]) * 1.01
+      fd = font_descender(style[:font_size]) * 1.01
+      x = absolute_left_margin
+      w = absolute_right_margin - absolute_left_margin
+      rectangle(x, y - fh + fd, w, fh).fill
+    end
+
+    fill_color  style[:foreground]
+    text(@toc_title, :font_size => style[:font_size],
+         :justification => style[:justification])
+
+    restore_state
+
+    self.y += font_descender(style[:font_size])#* 0.5
+
+    right = absolute_right_margin
+
+      # TODO -- implement tocdots as a replace tag and a single drawing tag.
+    @table_of_contents.each do |entry|
+      progress.inc if progress
+
+      info =  "<c:ilink dest='#{entry[:xref]}'>#{entry[:title]}</c:ilink>"
+      info << "<C:tocdots level='#{entry[:level]}' page='#{entry[:page]}' xref='#{entry[:xref]}'/>"
+
+      case entry[:level]
+      when 1
+        text info, :font_size => 16, :absolute_right => right
+      when 2
+        text info, :font_size => 12, :left => 50, :absolute_right => right
+      end
+    end
+  end
+
+  attr_accessor :techbook_codefont
+  attr_accessor :techbook_textfont
+  attr_accessor :techbook_encoding
+  attr_accessor :techbook_fontsize
+
+    # Start a new page: .newpage
+  def techbook_directive_newpage(args)
+    __render_paragraph
+
+    if args =~ /^force/
+      start_new_page true
+    else
+      start_new_page
+    end
+  end
+
+    # Preserved newlines: .pre
+  def techbook_directive_pre(args)
+    __render_paragraph
+    @techbook_mode = :preserved
+  end
+
+    # End preserved newlines: .endpre
+  def techbook_directive_endpre(args)
+    @techbook_mode = :normal
+  end
+
+    # Code: .code
+  def techbook_directive_code(args)
+    __render_paragraph
+    select_font @techbook_codefont, @techbook_encoding
+    @techbook_lastmode, @techbook_mode = @techbook_mode, :code
+    @techbook_textopt  = { :justification => :left, :left => 20, :right => 20 }
+    @techbook_fontsize = 10
+  end
+
+    # End Code: .endcode
+  def techbook_directive_endcode(args)
+    select_font @techbook_textfont, @techbook_encoding
+    @techbook_lastmode, @techbook_mode = @techbook_mode, @techbook_lastmode
+    @techbook_textopt  = { :justification => :full }
+    @techbook_fontsize = 12
+  end
+
+    # Eval: .eval
+  def techbook_directive_eval(args)
+    __render_paragraph
+    @techbook_lastmode, @techbook_mode = @techbook_mode, :eval
+  end
+
+    # End Eval: .endeval
+  def techbook_directive_endeval(args)
+    save_state
+
+    thread = Thread.new do
+      begin
+        @techbook_code.untaint
+        pdf = self
+        eval @techbook_code
+      rescue Exception => ex
+        err = PDF::Writer::Lang[:techbook_eval_exception]
+        $stderr.puts err % [ @techbook_line__, ex, ex.backtrace.join("\n") ]
+        raise ex
+      end
+    end
+    thread.abort_on_exception = true
+    thread.join
+
+    restore_state
+    select_font @techbook_textfont, @techbook_encoding
+
+    @techbook_code = ""
+    @techbook_mode, @techbook_lastmode = @techbook_lastmode, @techbook_mode
+  end
+
+    # Done. Stop parsing: .done
+  def techbook_directive_done(args)
+    unless @techbook_code.empty?
+      $stderr.puts PDF::Writer::Lang[:techbook_code_not_empty]
+      $stderr.puts @techbook_code
+    end
+    __render_paragraph
+    :break
+  end
+
+    # Columns. .columns <number-of-columns>|off
+  def techbook_directive_columns(args)
+    av = /^(\d+|off)(?: (\d+))?(?: .*)?$/o.match(args)
+    unless av
+      $stderr.puts PDF::Writer::Lang[:techbook_bad_columns_directive] % args
+      raise ArgumentError
+    end
+    cols = av.captures[0]
+
+      # Flush the paragraph cache.
+    __render_paragraph
+
+    if cols == "off" or cols.to_i < 2
+      stop_columns
+    else
+      if av.captures[1]
+        start_columns(cols.to_i, av.captures[1].to_i)
+      else
+        start_columns(cols.to_i)
+      end
+    end
+  end
+
+  def techbook_directive_toc(args)
+    @toc_title  = args unless args.empty?
+    @gen_toc    = true
+  end
+
+  def techbook_directive_author(args)
+    info.author = args
+  end
+  
+  def techbook_directive_title(args)
+    info.title  = args
+  end
+
+  def techbook_directive_subject(args)
+    info.subject  = args
+  end
+
+  def techbook_directive_keywords(args)
+    info.keywords = args
+  end
+
+  LIST_ITEM_STYLES = %w(bullet disc)
+
+  def techbook_directive_blist(args)
+    __render_paragraph
+    sm = /^(\w+).*$/o.match(args)
+    style = sm.captures[0] if sm
+    style = "bullet" unless LIST_ITEM_STYLES.include?(style)
+
+    @blist_factor = @left_margin * 0.10 if @blist_info.empty?
+
+    info = {
+      :left_margin  => @left_margin,
+      :style        => style
+    }
+    @blist_info << info
+    @left_margin += @blist_factor
+
+    @techbook_lastmode, @techbook_mode = @techbook_mode, :blist if :blist != @techbook_mode
+  end
+
+  def techbook_directive_endblist(args)
+    self.left_margin = @blist_info.pop[:left_margin]
+    @techbook_lastmode, @techbook_mode = @techbook_mode, @techbook_lastmode if @blist_info.empty?
+  end
+
+  def generate_table_of_contents?
+    @gen_toc
+  end
+
+  attr_accessor :techbook_source_dir
+
+  def self.run(args)
+    config = OpenStruct.new
+    config.regen      = false
+    config.cache      = true
+    config.compressed = false
+
+    opts = OptionParser.new do |opt|
+      opt.banner    = PDF::Writer::Lang[:techbook_usage_banner] % [ File.basename($0) ]
+      PDF::Writer::Lang[:techbook_usage_banner_1].each do |ll|
+        opt.separator "  #{ll}"
+      end
+      opt.on('-f', '--force-regen', *PDF::Writer::Lang[:techbook_help_force_regen]) { config.regen = true }
+      opt.on('-n', '--no-cache', *PDF::Writer::Lang[:techbook_help_no_cache]) { config.cache = false }
+      opt.on('-z', '--compress', *PDF::Writer::Lang[:techbook_help_compress]) { config.compressed = true }
+      opt.on_tail ""
+      opt.on_tail("--help", *PDF::Writer::Lang[:techbook_help_help]) { $stderr << opt; exit(0) }
+    end
+    opts.parse!(args)
+
+    config.document = args[0]
+
+    unless config.document
+      config.document = "manual.pwd"
+      unless File.exist?(config.document)
+        dirn = File.dirname(__FILE__)
+        config.document = File.join(dirn, File.basename(config.document))
+        unless File.exist?(config.document)
+          dirn = File.join(dirn, "..")
+          config.document = File.join(dirn, File.basename(config.document))
+          unless File.exist?(config.document)
+            dirn = File.join(dirn, "..")
+            config.document = File.join(dirn,
+                                        File.basename(config.document))
+            unless File.exist?(config.document)
+              $stderr.puts PDF::Writer::Lang[:techbook_cannot_find_document]
+              exit(1)
+            end
+          end
+        end
+      end
+
+      $stderr.puts PDF::Writer::Lang[:techbook_using_default_doc] % config.document
+    end
+
+    dirn = File.dirname(config.document)
+    extn = File.extname(config.document)
+    base = File.basename(config.document, extn)
+
+    files = {
+      :document => config.document,
+      :cache    => "#{base}._mc",
+      :pdf      => "#{base}.pdf"
+    }
+
+    unless config.regen
+      if File.exist?(files[:cache])
+        _tm_doc = File.mtime(config.document)
+        _tm_prg = File.mtime(__FILE__)
+        _tm_cch = File.mtime(files[:cache])
+        
+          # If the cached file is newer than either the document or the
+          # class program, then regenerate.
+        if (_tm_doc < _tm_cch) and (_tm_prg < _tm_cch)
+          $stderr.puts PDF::Writer::Lang[:techbook_using_cached_doc] % File.basename(files[:cache])
+          pdf = File.open(files[:cache], "rb") { |cf| Marshal.load(cf.read) }
+          pdf.save_as(files[:pdf])
+          File.open(files[:pdf], "wb") { |pf| pf.write pdf.render }
+          exit(0)
+        else
+          $stderr.puts PDF::Writer::Lang[:techbook_regenerating]
+        end
+      end
+    else
+      $stderr.puts PDF::Writer::Lang[:techbook_ignoring_cache] if File.exist?(files[:cache])
+    end
+
+      # Create the manual object.
+    pdf = PDF::TechBook.new
+    pdf.compressed = config.compressed
+    pdf.techbook_source_dir = File.expand_path(dirn)
+
+    document = open(files[:document]) { |io| io.read.split($/) }
+    progress = ProgressBar.new(base.capitalize, document.size)
+    pdf.techbook_parse(document, progress)
+    progress.finish
+
+    if pdf.generate_table_of_contents?
+      progress = ProgressBar.new("TOC", pdf.table_of_contents.size)
+      pdf.techbook_toc(progress)
+      progress.finish
+    end
+
+    if config.cache
+      File.open(files[:cache], "wb") { |f| f.write Marshal.dump(pdf) }
+    end
+
+    pdf.save_as(files[:pdf])
+  end
+
+  def techbook_text(line)
+    opt = @techbook_textopt.dup
+    opt[:font_size] = @techbook_fontsize
+    text(line, opt)
+  end
+
+  instance_methods.grep(/^techbook_directive_/).each do |mname|
+    private mname.intern
+  end
+end