deplate 0.7.3

data/lib/deplate/fmt/dbk-ref.rb

@@ -0,0 +1,105 @@
+# dbk-ref.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     17-M�r-2004.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.2124
+
+require "deplate/docbook"
+
+class Deplate::Formatter::DbkRef < Deplate::Formatter::Docbook
+    self.myname = "dbk-ref"
+    self.rx     = /dbk|dbk-ref|docbook/i
+
+    def initialize(deplate, args)
+        @headings = ["refsect1", "refsect2", "refsect3"]
+        super
+    end
+
+    def setup
+        @deplate.variables["headings"]   = "plain"
+        @deplate.variables['dbkClass'] ||= 'refentry'
+    end
+
+    def get_doc_open(args)
+        out = @deplate.variables["refentry"]
+        unless out
+            out = @deplate.options.out
+            out = File.basename(out, File.extname(out))
+            @deplate.variables["refentry"] = out
+        end
+        o = []
+        lang = @deplate.options.messages.prop('lang', self)
+        if lang
+            o << %{ lang="#{lang}"}
+        end
+        return %{<refentry id="%s"%s>} % [out, o.join]
+    end
+
+    def get_doc_close(args)
+        return "</refentry>"
+    end
+
+    # get_doc_head_open(args)
+    noop self, "get_doc_head_open"
+
+    # get_doc_head_close(args)
+    noop self, "get_doc_head_close"
+
+    def get_doc_head(args)
+        refentry      = @deplate.variables["refentry"]
+        refentrytitle = formatted_inline("refentrytitle", refentry)
+        manvolnum     = formatted_inline("manvolnum", @deplate.variables["manvol"] || "1")
+        refmeta       = formatted_block("refmeta", [refentrytitle, manvolnum].join("\n"))
+
+        refname    = formatted_inline("refname", refentry)
+        ti = @deplate.get_clip("title")
+        refpurpose = ti ? formatted_inline("refpurpose", ti.elt) : nil
+        refnamediv = formatted_block("refnamediv", [refname, refpurpose].join("\n"))
+
+        authors    = @deplate.options.author
+        accAuthors = docbook_authors(authors)
+        if authors.size > 1
+            refauthor = formatted_block("authorgroup", accAuthors.join("\n"))
+        else
+            refauthor = accAuthors.join("\n")
+        end
+
+        dt = @deplate.get_clip("date")
+        dt = dt.elt if dt
+        date = dt ? formatted_inline("date", dt) : nil
+
+        yr = @deplate.variables["copyrightYear"] || dt
+        if yr
+            year   = yr.split(/[\s,;]/).collect {|yr| formatted_inline("year", yr)}
+            holder = @deplate.get_clip("author")
+            holder = formatted_inline("holder", holder.elt) if holder
+            copyright = formatted_block("copyright", [year, holder].flatten.compact.join("\n"))
+        else
+            copyright = nil
+        end
+        
+        refentryinfo = [copyright || refauthor, date].compact
+        unless refentryinfo.empty?
+            refentryinfo = formatted_block("refentryinfo", refentryinfo.join("\n"))
+        else
+            refentryinfo = nil
+        end
+
+        # <refsynopsisdiv>
+        # <cmdsynopsis>
+        # <command>/usr/bin/ls</command>
+        # <arg choice="opt">
+          # <option>aAbcCdfFgilLmnopqrRstux1</option>
+        # </arg>
+        # <arg choice="opt" rep="repeat">file</arg>
+        # </cmdsynopsis>
+        # </refsynopsisdiv>
+
+        return [refentryinfo, refmeta, refnamediv].join("\n")
+    end
+    
+    noop self, "get_index"
+end
+

data/lib/deplate/fmt/dbk-slides.rb

@@ -0,0 +1,47 @@
+# dbk-slides.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     29-Apr-2005.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.13
+
+require 'deplate/docbook'
+
+# <+TBD+>Untested
+class Deplate::Formatter::DbkSlides < Deplate::Formatter::Docbook
+    self.myname = 'dbk-slides'
+    self.rx     = /dbk|dbk-slides|docbook/i
+    
+    def initialize(deplate, args)
+        @headings = ['foilgroup', 'foil']
+        super
+    end
+    
+    def setup
+        @deplate.variables['dbkClass'] ||= 'slides'
+    end
+    
+    # Document skeleton
+    def get_doc_open(args)
+        o = []
+        lang = @deplate.options.messages.prop('lang', self)
+        if lang
+            o << %{ lang="#{lang}"}
+        end
+        return "<slides#{o.join}>"
+    end
+
+    def get_doc_close(args)
+        return '</slides>'
+    end
+
+    def get_doc_head_open(args)
+        return '<slidesinfo>'
+    end
+
+    def get_doc_head_close(args)
+        return '</slidesinfo>'
+    end
+end
+

data/lib/deplate/fmt/dbk-snippet.rb

@@ -0,0 +1,21 @@
+# docbook-snippet.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     11-Aug-2005.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.17
+
+require 'deplate/fmt/dbk-article.rb'
+require 'deplate/formatter-snippet.rb'
+
+class Deplate::Formatter::DbkSnippet < Deplate::Formatter::DbkArticle
+    self.myname = "dbk-snippet"
+
+    include Deplate::Snippet
+
+    def format_paragraph(invoker)
+        invoker.elt
+    end
+end
+

data/lib/deplate/fmt/html-snippet.rb

@@ -0,0 +1,21 @@
+# html-snippet.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     11-Aug-2005.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.12
+
+require 'deplate/fmt/html.rb'
+require 'deplate/formatter-snippet.rb'
+
+class Deplate::Formatter::HTML_Snippet < Deplate::Formatter::HTML
+    self.myname = "html-snippet"
+
+    include Deplate::Snippet
+
+    def format_paragraph(invoker)
+        invoker.elt
+    end
+end
+

data/lib/deplate/fmt/html.rb

@@ -0,0 +1,1696 @@
+# fmt-html.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     17-M�r-2004.
+# @Last Change: 02-Nov-2005.
+# @Revision:    0.3513
+
+require 'uri'
+require 'parsedate'
+require 'time'
+require 'pathname'
+
+require 'deplate/formatter'
+
+# A sample html formatter.
+
+class Deplate::Formatter::HTML < Deplate::Formatter
+    self.myname = "html"
+    self.rx     = /html?/i
+    self.suffix = ".html"
+
+    self.label_delegate = [
+        :format_heading,
+        :format_LIST,
+        :format_anchor,
+        :format_list,
+        :format_list_env,
+    ]
+
+    self.label_once = [
+        :format_table,
+        :format_IMG,
+        :format_figure,
+        :format_IDX,
+        :format_MAKEBIB,
+        :format_paragraph,
+        :format_verbatim,
+    ]
+        
+    attr_accessor :html_class
+
+
+    ################################################ Setup {{{1
+    def initialize(deplate, args)
+        super
+        # Create OpenOffice compatible footnotes
+        @footnote_template = "sdfootnote%dsym"
+        @is_html_pageicons = false
+        @special_symbols = {
+            %{"} => %{&quot;},
+            %{>} => %{&gt;},
+            %{<} => %{&lt;},
+            %{&} => %{&amp;},
+            %{ } => lambda {|escaped| escaped ? "&nbsp;" : " "},
+        }
+        build_plain_text_rx
+        @encodings = {
+            'latin1' => 'iso-8859-1',
+        }
+    end
+
+    def hook_post_write_file_html
+        @deplate.options.css.each do |name, anyway|
+            begin
+                src  = @deplate.collected_css[name]
+                css  = File.basename(src)
+                dest = @deplate.auxiliary_filename(css, true)
+                if anyway or !File.exist?(dest)
+                    File.copy(src, dest)
+                    log(["Copy css file", css])
+                end
+            rescue
+                log(["Can't copy css file", css], :error)
+            end
+        end
+    end
+    
+    def hook_pre_body_flush_html
+        url = @variables["baseUrl"]
+        if url
+            fn = @deplate.output.top_heading.destination || @deplate.options.out
+            if fn && fn != "-"
+                fn  = Pathname.new(fn).expand_path
+                unless fn.dirname.to_s == "."
+                    pwd = Pathname.new(Dir.pwd).expand_path
+                    fn  = fn.relative_path_from(pwd).to_s.gsub(/\\/, "/")
+                    fp  = @variables["baseUrlStripDir"]
+                    if fp
+                        fn = fn.split(/\//)
+                        fn = fn[fp.to_i..-1]
+                        fn = File.join(*fn)
+                    end
+                end
+                url += fn
+                # if @variables["useDublinCore"]
+                    set_at(:pre, :head_identifier, head_meta_tag(%{name="DC.Identifier" content="%s"}) % url)
+                # else
+                # end
+            end
+        end
+
+        unless @is_html_pageicons
+            if @deplate.post_matter[@deplate.slot_by_name(:html_pageicons)]
+                consume_label('pageicons', true)
+                output_at(:post, :html_pageicons_beg, %{<div id="pageicons" class="pageicons">})
+                output_at(:post, :html_pageicons_end, %{</div>})
+                @is_html_pageicons = true
+            end
+        end
+
+        unless output_empty_at?(:body, :footnotes)
+            output_at(:body, :footnotes, :prepend, %{<div class="footnotes">})
+            output_at(:body, :footnotes, %{</div>})
+        end
+    end
+
+    def prepare
+        html_head
+
+        bodyOpts = @variables["bodyOptions"] || ""
+        output_at(:pre,  :body_beg, %{<body #{bodyOpts}>\n<a name="#pagetop"></a>})
+
+        output_at(:post, :body_end, "</body>")
+        output_at(:post, :doc_end,  "</html>")
+    end
+
+    def html_head
+        output_at(:pre, :doc_def,  head_doctype)
+        output_at(:pre, :doc_beg,  html_def)
+        output_at(:pre, :head_beg, "<head>")
+
+        t = @variables["encoding"] || "ISO-8859-1"
+        t = canonic_enc_name(t)
+        t = %{http-equiv="content-type" content="text/html; charset=#{t}"}
+        output_at(:pre, :head, head_meta_tag(t))
+
+        author = @deplate.get_clip('author')
+        author = clean_tags(author.elt) if author
+        desc   = @variables['description']
+        kw     = keywords
+        lang   = html_lang(true)
+
+        date   = @deplate.get_clip('date')
+        if date
+            date = date.elt
+            if date =~ /^\d\d(\d\d)$/
+                date = Time.local(date)
+            else
+                if date =~ /^(\w+)\s+(\d\d(\d\d))$/
+                    date = "1-#$1-#$2"
+                end
+                begin
+                    date = ParseDate.parsedate(date, true)
+                    date = Time.local(*date)
+                rescue
+                    log(["Can't parse date", @deplate.get_clip("date").elt], :error)
+                    date = nil
+                end
+            end
+        end
+        date ||= Time.now
+        # date   = date.xmlschema
+        date   = xmlschema(date)
+            
+        title = @deplate.get_clip("title")
+        title = clean_tags(title.elt) if title
+
+        if @variables["useDublinCore"]
+            output_at(:pre, :head_meta, head_meta_tag(%{name="DC.Title" content="%s"}) % title) if title
+            output_at(:pre, :head_meta, head_meta_tag(%{name="DC.Creator" content="%s"}) % author) if author
+            # DC.Subject
+            output_at(:pre, :head_meta, head_meta_tag(%{name="DC.Description" content="%s"}) % desc) if desc
+            # DC.Publisher, DC.Contributor
+            output_at(:pre, :head_meta, head_meta_tag(%{name="DC.Date" content="%s"}) % date) if date
+            # DC.Type, DC.Format, DC.Identifier, DC.Source
+            output_at(:pre, :head_meta, head_meta_tag(%{name="DC.Language" content="%s"}) % lang) if lang
+            # DC.Relation, DC.Coverage, DC.Rights
+        else
+            output_at(:pre, :head_meta, head_meta_tag(%{name="author" content="%s"}) % author) if author
+            output_at(:pre, :head_meta, head_meta_tag(%{name="description" content="%s"}) % desc) if desc
+            output_at(:pre, :head_meta, head_meta_tag(%{name="keywords" content="%s"}) % kw.join(", ")) if kw
+            output_at(:pre, :head_meta, head_meta_tag(%{name="language" content="%s"}) % lang) if lang
+            output_at(:pre, :head_meta, head_meta_tag(%{name="date" content="%s"}) % date) if date
+        end
+        output_at(:pre, :head_meta, head_meta_tag(%{name="generator" content="deplate.rb #{Deplate::Core.version}"})) unless @variables["noGenerator"]
+        md = @variables["metaDataExtra"]
+        output_at(:pre, :head_meta, md) if md
+        
+        output_at(:pre, :head_title, %{<title>%s</title>} % title) if title
+        
+        headExtra = @variables["headExtra"]
+        headExtra = headExtra.join("\n") if headExtra.kind_of?(Array)
+        output_at(:pre, :head_extra, headExtra) if headExtra and !headExtra.empty?
+       
+        css = head_css
+        output_at(:pre, :css, css) unless css.empty?
+
+        styleExtra = @variables["styleExtra"]
+        if styleExtra
+            styleExtra = styleExtra.join("\n") if styleExtra.kind_of?(Array)
+            styleExtra = <<EOH
+<style type="text/css">
+    <!--
+    #{styleExtra}
+    -->
+</style>
+EOH
+            output_at(:pre, :css, styleExtra) 
+        end
+
+        shortcutIcon = @variables["shortcutIcon"]
+        output_at(:pre, :head_end, head_link_tag(%{rel="shortcut icon" href="#{shortcutIcon}" type="image/x-icon"})) if shortcutIcon
+        pageicon = @variables["pageIcon"]
+        output_at(:pre, :head_end, head_link_tag(%{rel="icon" href="#{pageicon}" type="image/x-icon"})) if pageicon
+
+        output_at(:pre, :html_relations, @deplate.invoke_service("navigation_links")) unless @variables["noPageNavigation"]
+       
+        output_at(:pre, :head_end, @variables["explorerHack"])
+        output_at(:pre, :head_end, "</head>")
+    end
+
+    def head_meta_tag(text)
+        return %Q{<meta #{text}>}
+    end
+
+    def head_link_tag(text)
+        return %Q{<link #{text}>}
+    end
+
+    def xmlschema(time)
+        z = time.zone.scan(/([+-])(\d+):(\d+)/)[0]
+        z = z ? ("%s%02d:%02d" % z) : ""
+        if time.hour != 0 or time.min != 0 or time.sec != 0
+            time.strftime("%Y-%m-%dT%H:%M:%S" + z)
+        else
+            time.strftime("%Y-%m-%d")
+        end
+    end
+    private :xmlschema
+
+    def read_bib(bibfiles)
+        simple_bibtex_reader(bibfiles)
+    end
+    
+    def open_tag(invoker, tag, opts=nil, other_args={})
+        args   = invoker.args
+        single = other_args[:single] || false
+        no_id  = other_args[:no_id] || false
+        opts ||= {}
+        args ||= {}
+        unless no_id
+            id  = use_id(args, opts)
+            oid = opts['id']
+            if oid and oid != id
+                log(['ID mismatch', id, oid, opts, args], :error)
+            end
+            opts['id'] = encode_id(id) if id
+            # args = args.dup
+            args.delete('id')
+        end
+        id = opts['id']
+        unless consume_label(id)
+            opts = opts.dup
+            opts.delete('id')
+        end
+        cls = opts['class']
+        case cls
+        when Array
+            unless opts['class'].empty?
+                opts['class'] = opts['class'].join(' ')
+            end
+        when nil
+            opts['class'] = get_html_class(invoker)
+        end
+        opts = opts.collect do |k, v|
+            if v and !(v.empty?)
+                %{%s="%s"} % [k, v]
+            end
+        end
+        if single
+            opts << "/"
+        end
+        %{<%s>} % [tag, *opts].compact.join(" ")
+    end
+   
+    def consume_label(label, warn=false)
+        if !label
+            return false
+        elsif @consumed_labels.include?(label)
+            log(['Duplicate label'], label, :error) if warn
+            return false
+        else
+            @consumed_labels << label
+            return true
+        end
+    end
+    
+    def close_tag(invoker, tag)
+        %{</%s>} % tag
+    end
+
+    def inline_tag(invoker, tag, text, opts={})
+        [open_tag(invoker, tag, opts), text, close_tag(invoker, tag)].join
+    end
+    
+    def wrap_text(text, args={})
+        args[:check] ||= lambda do |line|
+            line =~ /<[^>]*$/
+        end
+        super(text, args)
+    end
+    
+    
+    ################################################ Lists {{{1
+    def format_list_item(invoker, type, level, item, html_class=nil, explicit=false)
+        indent = format_indent(level, true)
+        body = item.body
+        body = wrap_text(body) if body
+        opts = {"class" => []}
+        html_class ||= item.style || get_html_class(invoker)
+        if html_class
+            opts["class"] << html_class
+        end
+        case type
+        when "Numbered", "Itemize"
+            ev = list_item_explicit_value(item, explicit)
+            if ev
+                opts["value"] = ev
+            else
+                case item.item
+                when "-"
+                    opts["class"] << "dash"
+                when "+"
+                    opts["class"] << "plus"
+                when "*"
+                    opts["class"] << "asterisk"
+                when "�"
+                    opts["class"] << "bullet"
+                end
+            end
+            li = open_tag(invoker, "li", opts)
+            # indent1 = format_indent(level + 1, true)
+            # return %{#{indent}#{li}\n#{indent1}#{body}}, %{#{indent}</li>}
+            body = indent_text(body, level + 1)
+            return %{#{indent}#{li}\n#{body}}, %{#{indent}</li>}
+        when "Description"
+            dt = open_tag(invoker, "dt", opts)
+            dd = open_tag(invoker, "dd", opts)
+            accum = []
+            accum << "#{dt}#{item.item}</dt>\n" if item.item
+            accum << "#{dd}\n"
+            accum << indent_text(body, 1) if body
+            return indent_text(accum.join, level), "#{indent}</dd>"
+        when "Paragraph"
+            return indent_text(%{<br class="itempara" />#{body}}, 2), nil
+        else
+            raise "Unknown list type: #{item.inspect}"
+        end
+    end
+    
+    def format_list_env(invoker, type, level, what, subtype=nil)
+        indent = format_indent(level)
+        opts   = {'class' => []}
+        html_class ||= get_html_class(invoker)
+        if html_class
+            opts["class"] << html_class
+        end
+        case type
+        when "Numbered"
+            case subtype
+            when "a"
+                opts["type"] = "a"
+                opts['class'] << 'alpha'
+            when "A"
+                opts["type"] = "A"
+                opts['class'] << 'Alpha'
+            # when "1"
+            #     type = %{}
+            else
+                opts['class'] << 'numeric'
+            #     type = %{}
+            end
+            tag = "ol"
+        when "Itemize"
+            tag = "ul"
+        when "Description"
+            tag = "dl"
+        else
+            raise "Unknown list type: #{type}"
+        end
+        
+        case what
+        when :open
+            return indent + open_tag(invoker, tag, opts)
+        when :close
+            return indent + close_tag(invoker, tag)
+        end
+    end
+
+
+    ################################################ General {{{1
+    def format_environment(invoker, env, opts, text)
+        if text
+            ot = open_tag(invoker, env, opts)
+            ct = close_tag(invoker, env)
+            join_blocks([ot, text, "#{ct}\n"])
+        end
+    end
+
+    def get_html_class(invoker, default=nil)
+        html_class = [
+            invoker.args["htmlClass"],
+            invoker.styles_as_string,
+        ]
+        html_class.compact!
+        if invoker.respond_to?(:html_class)
+            hc = invoker.html_class
+            if invoker.respond_to?(:html_class=) and (!hc or hc.empty?)
+                invoker.html_class = default
+                html_class << default
+            end
+            if html_class.empty?
+                html_class << invoker.html_class
+            end
+        end
+        html_class.compact!
+        return html_class.empty? ? nil : html_class.join(" ")
+    end
+    
+    def format_label(invoker, mode=nil, label=nil, with_id=true)
+        accum   = []
+        label ||= invoker.label
+        label   = use_labels(invoker.args, label, :with_id => with_id)
+        unless !label or label.empty?
+            case mode
+            when :before
+                for l in label
+                    accum << %{<a name="#{l}">}
+                    @open_labels << l
+                end
+            when :after
+                for l in label
+                    if @open_labels.delete(l)
+                        accum << "</a>"
+                    end
+                end
+            when :closeOpen
+                while !@open_labels.empty?
+                    l = @open_labels.pop
+                    accum << format_label(invoker, :after)
+                end
+            # when :once
+            else
+                for l in label
+                    text = if block_given? then yield(l) else "" end
+                    accum << %{<a name="#{l}"></a>#{text}}
+                end
+            end
+        end
+        return accum.join
+    end
+
+    def format_figure(invoker, inline=false, elt=nil)
+        elt ||= invoker.elt
+        if inline
+            include_image(elt, invoker.args)
+        else
+            acc = []
+            fig     = @deplate.msg("Figure")
+            caption = invoker.caption
+            if caption
+                capAbove = !(caption && caption.args && caption.args.include?("below"))
+                lev      = invoker.level_as_string
+                # copts    = ["", %{style="text-align=#{float_align_caption(invoker)};"}]
+                # cap      = %{<p#{copts.join(" ")} class="caption">#{fig} #{lev}: #{caption.elt}</p>}
+                cap      = %{<p class="caption">#{fig} #{lev}: #{caption.elt}</p>}
+            else
+                capAbove = false
+            end
+            #+++options: here/top etc.
+            acc << %{<div class="figure">}
+            if caption and capAbove
+                acc << cap
+            end
+            acc << include_image(elt, invoker.args)
+            if caption and !capAbove
+                acc << cap
+            end
+            acc << "</div>\n"
+            join_blocks(acc)
+        end
+    end
+
+    def include_image(file, args, inline=false)
+        o = []
+        w = args["w"] || args["width"]
+        o << %{width="#{w}"} if w
+        h = args["h"] || args["heigth"]
+        o << %{height="#{h}"} if h
+        o = o.join(" ")
+        f = file[0..-(File.extname(file).size + 1)]
+        alt = args["alt"]
+        if alt
+            alt.gsub!(/[\\"&<>]/) do |s|
+                case s
+                when '\\'
+                    '\\\\'
+                else
+                    plain_text(s)
+                end
+            end
+        else
+            alt = File.basename(file, '.*')
+        end
+        style = [args["style"]]
+        style << "inline" if inline
+        style = style.compact.join(", ")
+        for sfx in image_suffixes
+            fs  = f + sfx
+            ff  = @deplate.auxiliary_filename(fs)
+            fff = @deplate.auxiliary_filename(fs, true)
+            if File.exist?(fff)
+                return %{<img src="#{ff}" #{o} alt="#{alt}" class="#{style}" />}
+            end
+        end
+        return %{<img src="#{file}" alt="#{alt}" class="#{style}" />}
+    end
+
+    def image_suffixes
+        [".png", ".jpeg", ".jpg", ".gif", ".bmp"]
+    end
+
+    ################################################ Elements {{{1
+    def format_note(invoker)
+        marker = invoker.marker
+        case marker
+        when "#"
+            html_class = "note"
+        when "+"
+            html_class = "warning"
+        when "?"
+            html_class = "caution"
+        when "!"
+            html_class = "important"
+        else
+            log(["Unknown marker", marker], :error)
+            html_class = "note"
+        end
+        cls = %{ class="%s"} % html_class
+        join_blocks(["<div#{cls}><p#{cls}>", invoker.elt, "</p></div>\n"])
+    end
+
+    def format_table(invoker)
+        args       = invoker.args
+        elt        = invoker.elt
+        caption    = invoker.caption
+        level_as_string   = invoker.level_as_string
+        style      = invoker.styles_as_string || @variables["tableStyle"]
+        style.gsub!(/[,;]+/, " ") if style
+        html_class = style || get_html_class(invoker)
+        capAbove   = !(caption && caption.args && caption.args.include?("below"))
+        clss       = html_class ? html_class : "standard"
+        clsss      = %{ class="#{clss}"}
+        opts       = format_particle(:table_args, invoker)
+        halfindent = "  "
+        indent     = halfindent * 2
+       
+        acc = []
+        unless args[:dontWrapTable]
+            acc << %{<div class="#{['table', style].compact.join(' ')}">}
+        end
+        acc << %{<table#{clsss}#{opts}>}
+        if caption
+            if !capAbove
+                capOpts = [%{ align="bottom"}]
+            else
+                # capOpts = [""]
+                capOpts = []
+            end
+            # capOpts << %{style="text-align=#{float_align_caption(invoker)};"}
+            cap = %{#{@deplate.msg("Table")} #{level_as_string}: #{caption.elt}}
+            acc << %{<caption#{capOpts.join(" ")}>#{cap}</caption>}
+        end
+      
+        acc_head = []
+        acc_foot = []
+        acc_body = []
+        elt.each_with_index do |r, n|
+            if r.head
+                row = formatted_table_row(n, r, args, indent, clss, "th")
+                if row
+                    table_add_row(acc_head, row, %{head #{style}}, :indent => halfindent)
+                end
+            elsif r.foot
+                row = formatted_table_row(n, r, args, indent, clss, "td")
+                if row
+                    table_add_row(acc_foot, row, %{foot #{style}}, :indent => halfindent)
+                end
+            elsif r.high
+                row = formatted_table_row(n, r, args, indent, clss, "td")
+                table_add_row(acc_body, row, %{high #{style}}, :indent => halfindent) if row
+            elsif r.is_ruler
+            else
+                row = formatted_table_row(n, r, args, indent, clss)
+                table_add_row(acc_body, row, clss, :indent => halfindent) if row
+            end
+        end
+
+        unless acc_head.empty?
+            acc << %{#{halfindent}<thead#{clsss}>}
+            acc << acc_head
+            acc << "#{halfindent}</thead>"
+        end
+        unless acc_foot.empty?
+            acc << %{#{halfindent}<tfoot#{clsss}>}
+            acc << acc_foot
+            acc << "#{halfindent}</tfoot>"
+        end
+        acc << acc_body
+
+        acc << "</table>"
+        note = invoker.args["note"]
+        if note
+            note  = @deplate.parse_and_format(invoker, note)
+            nopts = ['', %{class="tableNote"}]
+            align = float_align_note(invoker)
+            nopts << %{style="text-align=#{align};"} if align
+            acc   << %{<div#{nopts.join(' ')}>#{note}</div>}
+        end
+        acc << "</div>\n" unless args[:dontWrapTable]
+        acc << ""
+
+        join_blocks(acc)
+    end
+
+    def table_add_row(acc, row, clss, args)
+        tag       = args[:tag]    || "tr"
+        indent    = args[:indent] || "  "
+        dblindent = indent * 2
+        row = row.join("\n#{dblindent}")
+        acc << %{#{indent}<#{tag} class="#{clss}">}
+        acc << %{#{dblindent}#{row}}
+        acc << "#{indent}</#{tag}>"
+    end
+
+    def format_heading(invoker)
+        l         = format_label(invoker, nil, nil, false)
+        level     = invoker.level
+        args      = invoker.args
+        elt       = invoker.elt
+        html_args = invoker.html_args || ''
+        id        = invoker.get_id
+        if consume_label(id)
+            html_args += %{ id="#{id}"}
+        end
+        if level > 0 and level <= 6
+            hd = "h#{level}"
+            if invoker.plain_caption?
+                ls = ""
+            else
+                ls = invoker.level_as_string + "&nbsp;"
+            end
+            %{\n<#{hd}#{html_args}>#{l}#{ls}#{elt}</#{hd}>\n}
+        else
+            l += format_label(invoker, :string, [id]) if id
+            "\n#{l}#{elt}"
+        end
+    end
+
+    def format_list(invoker)
+        printable_list(invoker) + "\n"
+    end
+
+    def format_break(invoker)
+        format_pagebreak(invoker, "break")
+    end
+
+    def format_anchor(invoker)
+        format_label(invoker, :once)
+    end
+
+    def format_paragraph(invoker)
+        # html_class = get_html_class(invoker)
+        # cls = html_class.empty? ? "" : (%{ class="%s"} % html_class)
+        # join_blocks(["<p#{cls}>", indent_text(invoker.elt, 1), "</p>\n"])
+        # [open_tag(invoker, "p"), invoker.elt, close_tag(invoker, "p"), "\n"].join
+        [open_tag(invoker, "p"), wrap_text(invoker.elt), close_tag(invoker, "p"), "\n"].join
+    end
+
+
+    ################################################ Regions {{{1
+    def format_verbatim(invoker, text=nil)
+        text ||= invoker.elt
+        format_environment(invoker, "pre", {"class"=>"verbatim"}, plain_text(text, :pre))
+    end
+
+    def format_abstract(invoker)
+        format_environment(invoker, %{blockquote}, {"class"=>"abstract"}, invoker.elt)
+    end
+
+    def format_quote(invoker)
+        if invoker.args["long"]
+            format_environment(invoker, %{blockquote}, {"class"=>"quote"}, invoker.elt)
+        else
+            format_environment(invoker, %{blockquote}, {"class"=>"longquote"}, invoker.elt)
+        end
+    end
+
+    def format_header(invoker)
+        format_header_or_footer(invoker, :pre, :header, "HEADER", "header")
+        nil
+    end
+
+    def format_footer(invoker)
+        format_header_or_footer(invoker, :post, :footer, "FOOTER", "footer")
+        nil
+    end
+
+    
+    ################################################ Commands {{{1
+    def format_title(invoker)
+        acc = []
+        acc << %{<div class="title">}
+        for i, c in [["title",      %{<p class="title">%s</p>}],
+                     ["author",     %{<p class="author">%s</p>}], 
+                     ["authornote", %{<p class="authornote">%s</p>}],
+                     ["date",       %{<p class="date">%s</p>}]]
+            ii = @deplate.get_clip(i)
+            acc << c % ii.elt if ii
+        end
+        acc << %{</div>}
+        acc << format_pagebreak(invoker, "title") if invoker.args["page"]
+        join_blocks(acc)
+    end
+
+    alias :format_IMG :format_figure
+
+    alias :format_MAKETITLE :format_title
+
+    def format_MAKEBIB(invoker)
+        format_bibliography(invoker) do |key, labels, text|
+            consume_label(key, true)
+            %{<p id="#{key}" class="bib">#{labels}#{text}</p>}
+        end
+    end
+
+    def format_IDX(invoker)
+        invoker.elt
+    end
+
+    def format_pagebreak(invoker, html_class=nil, major=false)
+        if html_class
+            opt = %{ class="#{html_class}"}
+        else
+            opt = %{ class="pagebreak"}
+        end
+        # poor man's pagebreak
+        "<hr#{opt} />\n"
+    end
+
+
+    ################################################ Particles {{{1
+    def format_emphasize(invoker, text)
+        inline_tag(invoker, "em", text)
+    end
+    
+    def format_code(invoker, text)
+        inline_tag(invoker, "code", plain_text(text, :code))
+    end
+    
+    def format_url(invoker, name, dest, anchor, literal=false)
+        dest = Deplate::HyperLink.url_anchor(dest, anchor)
+        dest.gsub!(/&/, "&amp;")
+        inline_tag(invoker, "a", name, href_args(invoker, dest))
+    end
+
+    def format_wiki(invoker, name, dest, anchor)
+        dest = Deplate::HyperLink.url_anchor(dest, anchor)
+        # dest.gsub!(/&/, "&amp;")
+        inline_tag(invoker, "a", name, href_args(invoker, dest))
+    end
+   
+    def href_args(invoker, dest)
+        args = {"href" => dest}
+        target = invoker.args['target']
+        if target
+            args['target'] = target
+        end
+        return args
+    end
+    private :href_args
+    
+    def format_symbol(invoker, text)
+        case text
+        when "<-"
+            return "&larr;"
+        when "->"
+            return "&rarr;"
+        when "<=", "<<<"
+            return "&lArr;"
+        when "=>", ">>>"
+            return "&rArr;"
+        when "<->"
+            return "&harr;"
+        when "<=>"
+            return "&hArr;"
+        when "!="
+            return "&ne;"
+        when "~~"
+            return "&asymp;"
+        when "..."
+            return "&hellip;"
+        when "--"
+            return "&ndash;"
+        when "=="
+            return "&equiv;"
+        when "+++", "###", "???", "!!!"
+            m = plain_text(text)
+            return %{<span class="marker"><em class="marker">#{m}</em></span>}
+            # when "<~"
+            # return ""
+            # when "~>"
+            # return ""
+            # when "<~>"
+            # return ""
+        else
+            return plain_text(text)
+        end
+    end
+
+    def doublequote_open(invoker)
+        "&ldquo;"
+    end
+    
+    def doublequote_close(invoker)
+        "&rdquo;"
+    end
+    
+    def singlequote_open(invoker)
+        "&lsquo;"
+    end
+    
+    def singlequote_close(invoker)
+        "&rsquo;"
+    end
+
+    
+    ################################################ Macros {{{1
+    def format_index(invoker, idx)
+        if idx
+            return format_label(invoker, :string, [idx.label])
+        else
+            return ""
+        end
+    end
+
+    def format_footnote(invoker)
+        elt = invoker.elt
+        if elt and elt.elt and elt.elt.consumed
+            fn  = elt.elt
+            lab = fn.label
+            if !@deplate.footnotes_used.include?(lab)
+                idx      = @deplate.footnote_last_idx +=1
+                hclass   = "sdfootnoteanc"
+                id       = "sdfootnote%d"    % idx
+                name     = "sdfootnote%danc" % idx
+                href     = @footnote_template % idx
+                lab      = [href]
+                fn.n     = idx
+                fn.label = lab
+                @deplate.footnotes_used << lab
+                invoker.container.postponed_format << Proc.new do |container|
+                    consume_label(id, true)
+                    t = [%{<div id="#{id}">},
+                        %{<p class="sdfootnote">}, 
+                        %{<a class="sdfootnotesym" name="#{href}" href="##{name}">#{idx}</a>},
+                        %{#{fn.body}},
+                        %{</p></div>}]
+                    output_at(:body, :footnotes, t.join("\n"))
+                end
+            else
+                href = @footnote_template % fn.n
+            end
+            return %{<a class="sdfootnoteanc" name="#{name}" href="##{href}">#{fn.n}</a>}
+        else
+            return ""
+        end
+    end
+
+    def format_ref(invoker)
+        text = invoker.text || ""
+        f = @deplate.get_filename_for_label(invoker, text)
+        if f
+            # if invoker.args['obj'] and (o = @deplate.label_aliases[text])
+            o = @deplate.label_aliases[text]
+            if o
+                l = o.level_as_string
+            else
+                l = @deplate.labels[text]
+            end
+            if l
+                t = plain_text(l)
+            else
+                t = @variables["refButton"] || "[&rArr;]"
+            end
+            return %{&nbsp;<a href="#{URI.escape(f)}##{URI.escape(text)}" class="ref">#{t}</a>}
+        end
+    end
+
+    def format_linebreak(invoker)
+        open_tag(invoker, "br", nil, :single => true)
+    end
+
+    # def format_cite(invoker)
+    #     container = invoker.container
+    #     args = invoker.args
+    #     n    = args["n"]
+    #     p    = args["p"]
+    #     np   = args["np"]
+    #     y    = args["y"]
+    #     acc  = []
+    #     pmsg = @deplate.msg("p.\\ ")
+    #     for c in invoker.elt
+    #         cc = bib_entry(c)
+    #         if cc
+    #             yr = cc.assoc("year")
+    #             yr = if yr then yr[1] else "" end
+    #             if p
+    #                 p = @deplate.parse_and_format(container, "#{pmsg}#{p}")
+    #                 yr += ": #{p}"
+    #                 # yr  += ": " + p if p
+    #             end
+    #             if y
+    #                 acc << referenced_bib_entry(invoker, c, yr)
+    #             else
+    #                 nm = cc.assoc("author") || cc.assoc("editor")
+    #                 if nm
+    #                     nm = nm[1]
+    #                     nm = nm.gsub(/\s+/, " ").split(" and ").collect do |a|
+    #                         a.scan(/\w+$/)
+    #                     end
+    #                     nm   = nm.join(", ")
+    #                     acc << referenced_bib_entry(invoker, c, [nm, yr].join(" "))
+    #                 else
+    #                     acc << referenced_bib_entry(invoker, c, c)
+    #                 end
+    #             end
+    #         end
+    #     end
+    #     n &&= n + " "
+    #     acc = acc.join("; ")
+    #     if np
+    #         return %{#{n}#{acc}}
+    #     else
+    #         return %{&nbsp;(#{n}#{acc})}
+    #     end
+    # end
+
+    def referenced_bib_entry(invoker, key, text)
+        hd = @deplate.options.html_makebib_heading
+        f  = hd ? hd.top_heading.output_file_name(:relative => invoker.container) : ""
+        %{<a href="#{f}##{encode_id(key)}">#{text}</a>}
+    end
+    private :referenced_bib_entry
+    
+    def format_subscript(invoker)
+        inline_tag(invoker, "sub", invoker.elt)
+    end
+
+    def format_superscript(invoker)
+        inline_tag(invoker, "sup", invoker.elt)
+    end
+
+    # this doesn't work with IExplorer and others
+    def format_stacked(invoker)
+        elt = invoker.elt
+        sup = %{<span style="display:table-row"><sup style="display:table-cell">#{elt[0]}</sup></span>}
+        sub = %{<span style="display:table-row"><sub style="display:table-cell">#{elt[1]}</sub></span>}
+        stk = %{<span style="font-size: 80%; position:relative; top:0.5em; display:inline-table">#{sup}#{sub}</span>}
+        return stk
+    end
+
+    def format_pagenumber(invoker)
+        return ""
+    end
+
+
+    protected ######################################## private methods {{{1
+    ################################################ General {{{1
+    def clean_tags(text)
+        if text
+            t = text.gsub(/\<[^>]*?\>/, '')
+            t.gsub!(/^\s*$/, '')
+            t.gsub!(/^\n\s*/, '')
+            t.gsub!(/\n\s*$/, '')
+            t
+        end
+    end
+
+    def format_header_or_footer(invoker, type, slot, html_type, html_class)
+        args = invoker.args
+        acc  = []
+        acc << %{<div type="#{html_type}" class="#{html_class}">}
+        for e in invoker.elt
+            e.html_class = html_class
+            e.args[:dontWrapTable] = true
+            acc << e.format_current
+        end
+        acc << %{</div>}
+        output_at(type, slot, *acc)
+        nil
+    end
+
+
+    ################################################ Head {{{1
+    def head_css
+        csso = @variables["css"]
+        if csso
+            csss = csso.split(/\s+/)
+        else
+            csss = []
+        end
+        cls = @variables["class"]
+        if cls
+            csss << cls + ".css"
+        end
+        acc = []
+        csss.each_with_index do | f, i |
+            css, media = f.split(/\|/)
+            if css =~ /^\+/
+                css = css[1..-1]
+                with_title = false
+            else
+                with_title = true
+            end
+            cssName = File.basename(css, ".css")
+            cssFile = @deplate.auxiliary_filename(css)
+            opts = [%{rel="stylesheet" type="text/css" href="#{URI.escape(cssFile)}"}]
+            opts << %{title="#{cssName}"} if with_title
+            opts << %{media="#{media}"}  if media
+            acc << head_link_tag(opts.join(" "))
+        end
+        cssExtra = @variables["cssExtra"]
+        acc << cssExtra if cssExtra
+        return acc.join("\n")
+    end
+
+    def head_doctype
+        return %Q{<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">}
+    end
+    
+    def html_lang(stripped=false)
+        lang = @deplate.options.messages.prop('lang', self)
+        if lang
+            return stripped ? lang : %{lang="#{lang}"}
+        end
+    end
+
+    def html_def
+        acc = []
+        acc << html_lang
+        acc << @variables["htmlDefEtc"] if @variables["htmlDefEtc"]
+        if acc.empty?
+            return "<html>"
+        else
+            return "<html #{acc.join(" ")}>"
+        end
+    end
+    
+    
+    ################################################ List of ... {{{1
+    def format_list_of_contents(invoker)
+        format_list_of(invoker, "Table of Contents", @deplate.table_of_contents, "hd", 
+                       :flat => false, :html_class => "toc")
+    end
+
+    alias :format_list_of_toc :format_list_of_contents
+
+    def format_list_of_minitoc(invoker)
+        data = @deplate.table_of_contents.find_all {|e| e.level == 1}
+        format_list_of(invoker, "Contents", data, "hd", 
+                       :flat => false, :img => @variables["navGif"],
+                       :html_class => "minitoc") do |hd|
+            hd.args["shortcaption"] || hd.args["id"]
+        end
+    end
+
+    def format_list_of_tables(invoker)
+        format_list_of(invoker, "List of Tables", @deplate.table_of_tables, "tab", 
+                       :flat => true, :html_class => "lot")
+    end
+
+    def format_list_of_figures(invoker)
+        @html_class = "lof"
+        format_list_of(invoker, "List of Figures", @deplate.table_of_figures, "fig", 
+                       :flat => true, :html_class => "lof")
+    end
+
+    def format_list_of_index(invoker)
+        format_the_index(invoker, "Index", @deplate.index, "idx", 
+                         true, :html_class => "index")
+    end
+
+    def format_list_of(invoker, name, data, prefix, other_args)
+        args = invoker.args
+        flat = other_args[:flat] || false
+        img  = other_args[:img]  || nil
+        img  = %{<img src="#{img}" border="0" alt="" />} if img
+        html_class = get_html_class(invoker, other_args[:html_class])
+        name = args["title"] || name
+        id   = name.gsub(/\W/, "_")
+        
+        acc  = []
+        consume_label(id, true)
+        consume_label("#{id}Block", true)
+        acc << %{<div id="%s">%s\n<div id="%sBlock" class="%s">} % [id, img, id, html_class]
+        unless args["plain"] || args["noTitle"]
+            ti = @deplate.msg(name)
+            acc << %{<h1 class="%s">%s%s</h1>} % [html_class, format_label(invoker), ti]
+        end
+        
+        ll = 1
+        levels = args['levels']
+        if levels
+            range_from, range_to, rest = levels.split(/\.\./)
+            if rest
+                log(['Malformed range', levels], :error)
+            end
+        end
+        range_from ||= args['min']
+        if range_from
+            range_from = range_from.to_i
+        end
+        range_to ||= args['max']
+        if range_to
+            range_to = range_to.to_i
+        end
+        top = args['top']
+        if top
+            top = /^#{Regexp.escape(top)}/
+        end
+        sub = args['sub']
+        if sub
+            sub = /^#{Regexp.escape(invoker.level_as_string)}\./
+        end
+        accData = []
+        for hd in data
+            if hd.nil? or hd.args["noList"]
+                next
+            end
+            if range_from and hd.level < range_from
+                next
+            end
+            if range_to and hd.level > range_to
+                next
+            end
+            if top and hd.level_as_string !~ top
+                next
+            end
+            if sub and hd.level_as_string !~ sub
+                next
+            end
+            l = if flat then 1 else hd.level end
+            f = hd.output_file_name(:relative => invoker)
+            d = f + "#" + @deplate.elt_label(prefix, hd.level_as_string)
+            v = nil
+            if block_given?
+                v = yield(hd)
+            end
+            unless v
+                v = hd.caption ? hd.caption.elt : hd.elt.dup
+            end
+            # v.gsub!(/<a name=".*?"><\/a>/, "")
+            v = clean_tags(v)
+            v = [hd.level_as_string, v].join(" ") unless hd.plain_caption?
+            b = format_url(invoker, v, d, nil, true)
+            s = Deplate::ListItem.new(nil, b, "Itemize", "Itemize", l, 0, true)
+            s.style = html_class
+            accData << s
+        end
+        acc << printable_list(invoker, accData)
+        acc << %{</div></div>}
+        join_blocks(acc)
+    end
+
+    def format_the_index(invoker, name, data, prefix="", flat=false, other_args={})
+        html_class = other_args[:html_class] || "index"
+        accum  = []
+        chars  = []
+        
+        # accum << format_list_env(invoker, "Description", 0, :open)
+        for n, arr in sort_index_entries(data)
+            cht = get_first_char(n, true)
+            if !chars.include?(cht)
+                chars << cht
+                lab = format_label(invoker, :string, [format_index_hd_label(cht)])
+                accum << format_list_env(invoker, "Description", 0, :close) unless accum.empty?
+                accum << %{<h2 class="%s">%s%s</h2>} % [html_class, lab, cht]
+                accum << format_list_env(invoker, "Description", 0, :open)
+            end
+            acc = []
+            for i in arr
+                ff = @deplate.dest
+                if i.file or i.level_as_string
+                    f = i.file || invoker.output_file_name(:level_as_string => i.level_as_string, 
+                                                           :relative => invoker)
+                    if f == ff
+                        f = ""
+                        l = i.level_as_string
+                        if l and !l.empty?
+                            t = l
+                        elsif @deplate.options.multi_file_output
+                            t = @variables["refButton"] || "[&rArr;]"
+                        else
+                            t = "I"
+                        end
+                    else
+                        t = @deplate.file_with_suffix(f, "", true)
+                    end
+                    acc << format_url(invoker, t, f, i.label, true)
+                else
+                    log(["Index: Neither file nor level defined: dropping", i.label], :error)
+                end
+            end
+            l = format_label(invoker, :string, [format_index_entry_label(invoker, n)])
+            s = Deplate::ListItem.new(l + plain_text(n), acc.join(", "))
+            accum += format_list_item(invoker, "Description", 0, s)
+        end
+        accum << format_list_env(invoker, "Description", 0, :close)
+
+        acc = []
+        acc << %{<p class="%stoc">} % html_class
+        for c in chars
+            l = format_url(invoker, c, "", format_index_hd_label(c), true)
+            acc << l
+        end
+        acc << %{</p>}
+        acc << accum.join("\n")
+        join_blocks(acc)
+    end
+    
+    def format_index_entry_label(invoker, text)
+        return "idxEntry00" + text.gsub(/\W/, "00")
+    end
+
+    def format_index_hd_label(char)
+        return "hdIdx#{char}"
+    end
+   
+
+    ################################################ Table {{{1
+    def table_args(invoker)
+        args    = invoker.args
+        caption = invoker.caption
+        opts    = [nil]
+        align   = float_align(invoker)
+        case align
+        when "center"
+        when "right"
+        when "left"
+        end
+        opts << %{align="#{align}"} if align
+        width = args["width"] || @variables["tableWidth"]
+        opts << %{width="#{width}"} if width
+        opts << %{summary="#{caption.elt}"} if caption and caption.elt
+        return opts.join(" ")
+    end
+
+    def float_align(invoker)
+        args = invoker.args
+        args["align"] || @variables["floatAlign"]
+        # || "center"
+    end
+
+    def float_align_caption(invoker)
+        float_align(invoker)
+        # || "left"
+    end
+    
+    def float_align_note(invoker)
+        float_align(invoker)
+        # || "left"
+    end
+    
+    def formatted_table_row(n, row, args, indent, html_class=nil, thistag=nil)
+        colwidths = Deplate::Core.props(args["cols"], "w")
+        coljusts  = Deplate::Core.props(args["cols"], "j")
+        rowheight = Deplate::Core.props(args["rows"], "h")
+        t = []
+        row.cols.each_with_index do |cell, i|
+            case cell
+            when :join_left, :join_above
+            when :ruler, :noruler
+                return nil
+            else
+                c = cell.cell
+                if thistag
+                    tag = thistag
+                else
+                    if row.head
+                        tag = "th"
+                    else
+                        tag = "td"
+                    end
+                end
+
+                opts = []
+                opts << if row.head
+                            %{ class="head #{html_class}"}
+                        elsif row.foot
+                            %{ class="foot #{html_class}"}
+                        elsif cell.high or row.high
+                            %{ class="high #{html_class}"}
+                        else
+                            %{ class="#{html_class}"}
+                        end
+
+                styles = []
+                w = colwidths[i]
+                if w and !w.empty?
+                    styles << %{width:%s} % w
+                end
+                j = coljusts[i]
+                if j and !j.empty?
+                    styles << %{text-align:%s} % j
+                end
+                h = rowheight[n]
+                if h and !h.empty?
+                    styles << %{height:%s} % h
+                end
+
+                if styles.empty?
+                    styles = ""
+                else
+                    opts << %{style="%s"} % styles.join("; ")
+                end
+
+                if cell.span_x > 1
+                    opts << %{colspan="#{cell.span_x}"}
+                end
+                if cell.span_y > 1
+                    opts << %{rowspan="#{cell.span_y}"}
+                end
+
+                # t << "<#{tag}#{opts.join(" ")}>#{indented(c, indent)}\n#{indent}</#{tag}>"
+                t << "<#{tag}#{opts.join(" ")}>#{c}</#{tag}>"
+            end
+        end
+        t
+    end
+    
+    def indented(text, indent)
+        return text.collect do |l|
+            indent + l
+        end
+    end
+
+
+    public
+    ################################################ navigation bar {{{1
+    def format_navigation_bar(invoker, type, slot, bartype, first=false, last=false)
+        idx, first, last = navbar_output_index(invoker, first, last)
+
+        nomenu    = invoker.args['noNavMenu'] || @variables['noNavMenu']
+        nobuttons = invoker.args['noNavButtons'] || @variables['noNavButtons']
+        
+        navbar_begin(type, slot, idx)
+        navbar_menu(type, slot, idx, bartype) unless nomenu
+        unless nobuttons
+            urlp, prv = navbar_button_prev(type, slot, idx, bartype, !first && idx > 0)
+            url, home = navbar_button_home(type, slot, idx, bartype, idx > 0)
+            urln, nxt = navbar_button_next(type, slot, idx, bartype, !last)
+
+            case bartype
+            when :top, :inline
+                if urlp
+                    titp      = @deplate.options.heading_names[idx - 1]
+                    link_prev = head_link_tag(%{rel="previous" href="#{urlp}" title="#{clean_tags(titp)}"})
+                    set_at(:pre, :htmlsite_prev,  link_prev)
+                end
+                if urln
+                    titn      = @deplate.options.heading_names[idx + 1]
+                    link_next = head_link_tag(%{rel="next" href="#{urln}" title="#{clean_tags(titn)}"})
+                    set_at(:pre, :htmlsite_next, link_next)
+                    urlspace = urln
+                else
+                    urlspace = url
+                end
+                if url
+                    tit       = @deplate.options.heading_names[0]
+                    link_up   = head_link_tag(%{rel="up" href="#{url}" title="#{clean_tags(tit)}"})
+                    set_at(:pre, :htmlsite_up, link_up)
+                end
+                unless bartype == :inline or @variables["noBindKeys"]
+                    output_at(:body, :navbar_js, html_navigation_keys({"next" => urlspace}, ""))
+                end
+            else
+                if (first or idx == 0) and !@variables["noNavigationNote"]
+                    output_at(type, slot, @deplate.invoke_service("navigation_note"))
+                end
+            end
+        end
+        navbar_end(type, slot, idx)
+    end
+
+    def navbar_button_prev(type, slot, idx, bartype, ok)
+        if ok
+            text = @variables["prevButton"] || @deplate.formatter.plain_text("<<")
+            urlp = navbar_guess_file_name(idx - 1, idx, bartype)
+            ak  = bartype == :top ? %{ accesskey="B"} : ""
+            prv = %{<a class="navbarUrl" title="Previous" href="#{urlp}"#{ak}>#{text}</a>}
+        else
+            urlp = nil
+        end
+        unless urlp
+            prv  = "&nbsp;"
+        end
+        navbar_add_element(type, slot, idx, prv, "navbar")
+        return urlp, prv
+    end
+   
+    def navbar_button_home(type, slot, idx, bartype, ok)
+        if ok or @variables["homeShowAlways"]
+            text = @variables["homeButton"] || "[-]"
+            url  = navbar_guess_file_name(0, idx, bartype) || "#pagetop"
+            ak   = [:top, "navbar"].include?(bartype) ? %{ accesskey="H"} : ""
+            hc   = ["navbar"].include?(bartype) ? "navBar" : "navbarUrl"
+            home = %{<a class="#{hc}" title="Home" href="#{url}"#{ak}>#{text}</a>}
+        else
+            url  = nil
+        end
+        unless url
+            home = "&nbsp;"
+        end
+        navbar_add_element(type, slot, idx, home, "navbar")
+        return url, home
+    end
+
+    def navbar_button_next(type, slot, idx, bartype, ok)
+        if ok
+            text = @variables["nextButton"] || @deplate.formatter.plain_text(">>")
+            urln = navbar_guess_file_name(idx + 1, idx, bartype)
+            ak   = bartype == :top ? %{ accesskey="N"} : ""
+            nxt  = %{<a class="navbarUrl" title="Next" href="#{urln}"#{ak}>#{text}</a>}
+        else
+            urln = nil
+        end
+        unless urln
+            nxt  = "&nbsp;"
+        end
+        navbar_add_element(type, slot, idx, nxt, "navbar")
+        return urln, nxt
+    end
+    
+    def navbar_menu(type, slot, idx, bartype)
+        unless @deplate.options.navmenu
+            navmenu = [%{<form action=""><select class="navmenu" name="Contents"
+              onChange="self.location.href=this.form.Contents.options[this.form.Contents.options.selectedIndex].value">}, 
+              %{<option value="">[ #{@deplate.msg("Contents")} ]</option>},
+              %{<option value="">------------------------</option>}]
+   
+            acc = []
+            @variables["@contents"] ||= acc
+            @deplate.each_heading(:top) do |hd, title|
+                file = hd.output_file_name(:basename => true)
+                unless hd.kind_of?(Deplate::NullTop)
+                    anchor = hd.get_id
+                    if anchor
+                        file += "##{anchor}"
+                    end
+                    acc << [title, file]
+                end
+                navmenu << %{<option value="#{file}">#{title}</option>}
+            end
+
+            navmenu << %{</select>}
+            # navmenu << %{<button class="navgo" name="Go" type="button" value="Go" onClick="self.location.href=this.form.Contents.options[this.form.Contents.options.selectedIndex].value">}
+            # navmenu << %{<p class="navgo">%s</p>} % (@variables["goButton"] || "Go")
+            # navmenu << %{</button>}
+            navmenu << %{</form>}
+            @deplate.options.navmenu = navmenu.join("\n")
+        end
+        navbar_add_element(type, slot, idx, @deplate.options.navmenu, "navmenu")
+    end
+    
+    
+    ################################################ Site navigation {{{1
+    def format_navigation_links(depth)
+        acc = []
+        start = navbar_guess_file_name(0, nil, :inline)
+        if start and start != ""
+            title = @deplate.msg("Frontpage")
+            acc << head_link_tag(%{rel="start" href="#{start}" title="#{clean_tags(title)}"})
+        end
+        tags = ["", "chapter", "section", "subsection"]
+        @deplate.each_heading(depth || 2) do |hd, title|
+            ref    = tags[hd.level]
+            anchor = hd.args[:id] || hd.label.first
+            file   = hd.output_file_name(:basename => true)
+            file   = [file, "#", anchor].join if anchor
+            acc << head_link_tag(%{rel="#{ref}" href="#{file}" title="#{clean_tags(title)}"})
+        end
+        acc.join("\n")
+    end
+    
+    def navbar_guess_file_name(idx, base, bartype, section=nil)
+        b  = @deplate.output_filename_by_idx(base)
+        ff = @deplate.output_filename_by_idx(idx)
+        f  = @deplate.relative_path_by_file(ff, b)
+        if bartype == :inline
+            section ||= @deplate.top_heading_by_idx(idx)
+            if section
+                anchor = section.args[:id] || section.label.first
+                if anchor and anchor != "deplateNullTop"
+                    f = [f, "#", anchor].join
+                end
+            end
+        end
+        return f
+    end
+
+
+    private
+    def navbar_begin(type, slot, idx)
+        output_at(type, slot, %{<table class="navbar"><tr class="navbar">})
+    end
+    
+    def navbar_end(type, slot, idx)
+        output_at(type, slot, %{</tr></table>})
+    end
+    
+    def navbar_add_element(type, slot, idx, element, htmlclass)
+        if !@variables["noTabBarButtons"] and type and slot
+            output_at(type, slot, %{<td class="#{htmlclass}">#{element}</td>})
+        end
+    end
+
+    def navbar_output_index(invoker, first=false, last=false)
+        acc = []
+        if invoker.respond_to?(:top_heading)
+            th = invoker.top_heading
+            acc << @deplate.output_index(th)
+            acc << first || th.first_top
+            acc << last  || th.last_top
+        else
+            idx = @deplate.output_index
+            acc << idx
+            acc << (first || (idx == 0))
+            acc << (last  || (@deplate.number_of_outputs == idx + 1))
+        end
+        return acc
+    end
+
+end
+
+
+class Deplate::Core
+    def formatter_initialize_html
+        @doc_services["navigation_bar"]   = :html_navigation_bar
+        @doc_services["navigation_note"]  = :html_navigation_note
+        @doc_services["navigation_keys"]  = :html_navigation_keys
+        @doc_services["navigation_links"] = :html_navigation_links
+        @html_navigation_note = nil
+    end
+
+    def html_navigation_links(args, text)
+        depth = args["depth"]
+        depth &&= depth.to_i
+        @formatter.format_navigation_links(depth)
+    end
+
+    def html_navigation_bar(args, text)
+        type = :array
+        slot = []
+        invoker = args[:invoker]
+        if invoker
+            invoker.args.update(args)
+        else
+            invoker = Deplate::PseudoContainer.new(@deplate, :args => args)
+        end
+        @formatter.format_navigation_bar(invoker, type, slot, :inline)
+        slot.join("\n")
+    end
+
+    # 8  ... BS
+    # 9  ... tab
+    # 13 ... enter
+    # 16 ... shift
+    # 17 ... ctrl
+    # 18 ... alt
+    # 27 ... esc
+    # 32 ... space
+    # 37 ... left
+    # 39 ... right
+    # 78 ... n
+    # 191 ... #
+    def html_navigation_keys(args, text)
+        nextKey = @variables["nextKey"] || "16"
+        nextKey = ",%s," % nextKey.split(/\s*,\s*/).join(",")
+        prevKey = @variables["prevKey"] || "8"
+        prevKey = ",%s," % prevKey.split(/\s*,\s*/).join(",")
+        acc     = []
+        if nextKey.to_i > 0
+            acc << <<-EOJS
+            <script type="text/javascript">
+                <!--
+                    function HandleSpace() {
+                        this.event = function(e) {
+                            if (!e) { e = window.event; }
+            EOJS
+            if args["next"]
+                acc << <<-EOJS
+                            if ("#{nextKey}".indexOf(","+ e.keyCode +",") != -1) {
+                                window.location="#{args["next"]}";
+                            }
+                EOJS
+            end
+            acc << <<-EOJS
+                        };
+                        var self = this;
+                    }
+                    var k = new HandleSpace();
+                    document.onkeydown = k.event;
+                //-->
+            </script>
+            EOJS
+        end
+        acc.join
+    end
+    
+    def html_navigation_note(args, text)
+        unless @html_navigation_note
+            @html_navigation_note   = msg(:htmlnavigation_note)
+            unless @html_navigation_note
+                @html_navigation_note = [
+                    %{<p class="htmlnavigationnote" />},
+                    %{<hr class="htmlnavigationnote" />},
+                    %{<p class="htmlnavigationnote">Navigation tips:</p>},
+                    %{<ul class="htmlnavigationnote">},
+                    %{<li class="htmlnavigationnote"> Press &lt;a-n&gt; to jump to the next page</li>},
+                    if args['nextKey'] then
+                    %{<li class="htmlnavigationnote"> Press &lt;#{args['nextKey']}&gt; to jump to the next page</li>}
+                    end,
+                        %{<li class="htmlnavigationnote"> Press &lt;a-b&gt; to jump to the previous one</li>},
+                        %{<li class="htmlnavigationnote"> Press &lt;a-h&gt; to jump to the title page</li>},
+                        %{<li class="htmlnavigationnote"> It depends on the browser whether 
+                these shortcuts are activated (e.g. Mozilla) or just selected (e.g. MS IE), 
+                in which case you have to press &lt;enter&gt;</li>},
+                %{</ul>},
+                ].join("\n")
+            end
+        end
+        return @html_navigation_note
+    end
+end
+
+
+class Deplate::Element
+    attr_accessor :html_class, :html_args
+
+    def hook_pre_setup_html
+        @html_class = nil
+        @html_args  = nil
+    end
+end
+
+
+class Deplate::Command::MAKEBIB
+    accumulate_pre(self, Deplate::Formatter::HTML) do |src, array, deplate, text, match, args, cmd|
+        unless args['plain']
+            n = Deplate::Element::Heading.markup(deplate.msg('Bibliography'))
+            m = Deplate::Element::Heading.match(n)
+            Deplate::Element::Heading.accumulate(src, array, deplate, n, m)
+            o = array[-1]
+            o.finish.update_options(args)
+            deplate.options.html_makebib_heading = o
+        end
+    end
+end
+
+
+class Deplate::Command::LIST
+    accumulate_pre(self, Deplate::Formatter::HTML) do |src, array, deplate, text, match, args, cmd|
+        if text == 'index' and !args['plain'] and !args['noTitle']
+            n = Deplate::Element::Heading.markup(deplate.msg('Index'))
+            m = Deplate::Element::Heading.match(n)
+            Deplate::Element::Heading.accumulate(src, array, deplate, n, m)
+            o = array[-1]
+            o.finish.update_options(args)
+        end
+    end
+end
+
+
+# vim: ff=unix