deplate 0.7.3 → 0.8

data/lib/deplate/etc.rb

@@ -3,18 +3,38 @@
 # @Website:     http://deplate.sf.net/
 # @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
 # @Created:     16-Okt-2005.
-# @Last Change: 01-Nov-2005.
-# @Revision:    0.30
+# @Last Change: 29-Apr-2006.
+# @Revision:    0.308
 
 require 'deplate/common'
 
+
+module Deplate::Rx
+    # This function builds recursive regular expressions that are used 
+    # for parsing macros and skeletons. The optional argument defines 
+    # the depth of nested macros for which the regular expression is 
+    # being built. The default is 5 which should be sufficient due to 
+    # the primitivity of the macro language. The string "{#}" is 
+    # replaced with the regexp itself.
+    def builder(rx_source, rx_opts=nil, depth=5, sol=true)
+        rxr = rx_source.gsub('\\', '\\\\\\\\')
+        for i in 1..depth
+            rx_source.gsub!(/\{#\}/, rxr)
+        end
+        rx_source.gsub!(/\{#\}/, '[^{}]+?')
+        rx_source = '^' + rx_source if sol
+        return Regexp.new(rx_source, rx_opts)
+    end
+    module_function :builder
+end
+
 class Deplate::PseudoContainer < Deplate::BaseElement
     attr_accessor :registered_metadata
     attr_reader   :destination
     
     def initialize(deplate, args)
         super(deplate, args)
-        @level_as_string     = args[:level_as_string]
+        self.level_as_string = args[:level_as_string]
         @top_heading         = args[:top] || deplate.get_current_top
         @registered_metadata = args[:metadata] || []
         @accum               = args[:accum] || []
@@ -38,14 +58,15 @@ end
 
 
 class Deplate::NullTop < Deplate::PseudoContainer
-    attr_reader   :args, :caption
+    attr_reader   :args, :caption, :level_heading
     attr_accessor :first_top, :last_top, :description
 
     def initialize(deplate, args)
         super
+        @level_heading = [0]
         @destination = args[:destination]
-        @args        = {:id => "deplateNullTop"}
-        @caption     = deplate.msg("[Start]")
+        @args        = {:id => 'deplateNullTop'}
+        @caption     = Deplate::CaptionDef.new(deplate.msg('[Start]'), {}, nil)
         @description = nil
         @first_top   = false
         @last_top    = false
@@ -55,6 +76,72 @@ class Deplate::NullTop < Deplate::PseudoContainer
 end
 
 
+module Deplate::Footnote
+    attr_reader :fnId
+    # Quack like Deplate::Region
+    attr_reader :accum, :regNote, :label, :level, :caption, :captionOptions
+
+    def footnote_setup(text)
+        if text
+            @fnId = @args['id']
+            if @fnId and text and !text.empty?
+                @regNote = @fnId
+                @accum   = text
+                # @level   = @container.level
+                fn = Deplate::Regions::Footnote.new(@deplate, @source, @regNote, {}, self)
+                fn.finish
+            else
+                @fnId ||= text
+            end
+            if @container.kind_of?(Deplate::Element::Table)
+                @container.contains_footnotes = true
+            end
+        else
+            log('No footnote ID', :error)
+        end
+    end
+
+    def footnote_process
+        fn = @deplate.footnotes[@fnId]
+        if fn
+            # fn.elt.consumed = true
+            fn.fn_consumed = true
+            @elt = fn
+        else
+            log(['Unknown footnote', @fnId, @deplate.footnotes.keys.inspect], :error)
+            @elt = nil
+        end
+        return format_particle(:format_footnote, self)
+    end
+end
+
+
+class Deplate::IndexEntry
+    attr_accessor :container, :name, :synonymes, :label
+    attr_writer :file, :level_as_string
+    
+    def initialize(container)
+        @container = container
+        unless container
+            # p "DBG IndexEntry: container = nil"
+        end
+        if block_given?
+            yield(self)
+        end
+    end
+
+    def file(invoker=nil)
+        # @file || (@container && @container.output_file_name(:relative => invoker))
+        @file
+    end
+
+    def level_as_string
+        # @level_as_string || (@container && @container.level_as_string)
+        @level_as_string
+    end
+end
+
+
 class Deplate::Source
     attr_accessor :file, :begin, :end, :level_as_string, :stats
     
@@ -68,104 +155,12 @@ class Deplate::Source
 end
 
 
-module Deplate::Symbols
-end
+# module Deplate::Symbols
+# end
 
 
-class Deplate::Variables < Hash
-    attr_accessor :deplate
-    
-    def initialize(deplate=nil)
-        super()
-        @deplate = deplate
-    end
-  
-    def update(hash)
-        for key, val in hash
-            self[key] = val
-        end
-    end
-    
-    def []=(name, value)
-        if (m = /^(\S+)\[(\S+)?\]$/.match(name))
-            key   = m[1]
-            field = m[2]
-            var   = self[key]
-            if !var
-                if !field
-                    self[key] = [value]
-                elsif field =~ /^[0-9]$/
-                    self[key] = []
-                    self[key][field.to_i] = value
-                else
-                    self[key] = {field => value}
-                end
-            elsif var.kind_of?(Struct) || var.kind_of?(OpenStruct)
-                var.send("#{field}=", value)
-            elsif var.kind_of?(Hash)
-                var[field] = value
-            elsif var.kind_of?(Array)
-                if !field
-                    var << value
-                elsif field =~ /^[0-9]+$/
-                    field = field.to_i
-                    var[field] = value
-                else
-                    Deplate::Core.log(["Wrong index", field, name, var.class], :error)
-                end
-            elsif var
-                Deplate::Core.log(["Doc variable has wrong type", key, var.class], :error)
-            end
-        else
-            super
-        end
-    end
-    
-    def [](name)
-        begin
-            if keys.include?(name)
-                return super
-            elsif name =~ /^\S+\(.*\)$/
-                m = /^(\S+)\((.*?)?\)$/.match(name)
-                if m
-                    method = m[1]
-                    args   = m[2]
-                    args, text = @deplate.input.parse_args(args, nil, false)
-                    return @deplate.invoke_service(method, args, text)
-                else
-                    Deplate::Core.log(["Malformed variable name", name], :error)
-                end
-            elsif (m = /^(\S+)\[(\S+)\]$/.match(name))
-                key   = m[1]
-                field = m[2]
-                var   = self[key]
-                if var.kind_of?(Struct) || var.kind_of?(OpenStruct)
-                    return var.send(field)
-                elsif var.kind_of?(Hash)
-                    return var[field]
-                elsif var.kind_of?(Array)
-                    if field =~ /^[0-9]+$/
-                        field = field.to_i
-                        return var[field]
-                    else
-                        Deplate::Core.log(['Wrong index', field, name, var.class], :error)
-                    end
-                elsif var
-                    # <+TBD+> this is unsave
-                    # return var.send(field)
-                    Deplate::Core.log(['Variable has wrong type', key, var.class], :error)
-                else
-                    Deplate::Core.log(['Unknown variable', key], :error)
-                end
-            end
-        rescue Exception => e
-            Deplate::Core.log(['Retrieving doc variable failed', name, e], :error)
-        end
-        return nil
-    end
-end
-
 module Deplate::Void
+    module_function
 end
 
 # Based on code by:
@@ -197,3 +192,70 @@ class << Deplate::Safe
     end
 end
 
+
+class Deplate::Symbols < Deplate::CommonObject
+    class_attribute :myname
+
+    class << self
+        def hook_post_myname=(name)
+            klass = self
+            Deplate::Core.declare_symbols(name, klass)
+        end
+
+        def register_as(*names)
+            for n in names
+                hook_post_myname=(n)
+            end
+        end
+    end
+
+    def initialize(deplate)
+        @deplate   = deplate
+        @formatter = @deplate.formatter
+    end
+    
+    def symbol_quote(invoker)
+        '"'
+    end
+
+    def symbol_gt(invoker)
+        ">"
+    end
+
+    def symbol_lt(invoker)
+        "<"
+    end
+
+    def symbol_amp(invoker)
+        "&"
+    end
+
+    def doublequote_open(invoker)
+        %{"}
+    end
+
+    def doublequote_close(invoker)
+        %{"}
+    end
+
+    def singlequote_open(invoker)
+        %{'}
+    end
+
+    def singlequote_close(invoker)
+        %{'}
+    end
+
+    def nonbreakingspace(invoker)
+        %{ }
+    end
+
+    def symbol_paragraph(invoker)
+        %{§}
+    end
+
+    def format_symbol(invoker, sym)
+        return @formatter.plain_text(sym)
+    end
+end
+

data/lib/deplate/external.rb

@@ -3,8 +3,8 @@
 # @Website:     http://deplate.sf.net/
 # @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
 # @Created:     04-Sep-2004.
-# @Last Change: 28-Okt-2005.
-# @Revision:    0.168
+# @Last Change: 08-Apr-2006.
+# @Revision:    0.206
 
 require "ps2ppm"
 
@@ -26,12 +26,19 @@ module Deplate::External
     end
 
     def get_app(name, default=nil)
-        @@apps[name] || default || name
+        app = @@apps[name]
+        unless app
+            app = default || name
+            if RUBY_PLATFORM =~ /mswin/ and app !~ /\.\w+$/
+                app += '.exe'
+            end
+        end
+        app
     end
 
     def log_popen(container, cmd)
         rv = []
-        if container.deplate.options.allow_external
+        if container.deplate.allow_external
             container.log(["PWD", Dir.pwd])
             container.log(["Exec", cmd])
             begin
@@ -41,8 +48,8 @@ module Deplate::External
                     else
                         until io.eof
                             l = io.gets
-                            rv << l
-                            puts l
+                            rv << l.chomp
+                            puts l unless Deplate::Core.quiet?
                         end
                     end
                 end
@@ -60,7 +67,7 @@ module Deplate::External
     # directory, i.e., that the proper working directory was previously  
     # set
     def write_file(container, filename, &block)
-        if container.deplate.options.allow_external
+        if container.deplate.allow_external
             File.open(filename, "w") {|io| block.call(io)}
         end
     end
@@ -79,21 +86,45 @@ module Deplate::External
     end
 
     def ps2img(instance, device, psfile, outfile, args)
-        r = args["rx"] || instance.deplate.variables["ps2imgRes"] || 96
-        # r = args["rx"] || instance.deplate.variables["ps2imgRes"] || 120
+        # r = args["rx"] || instance.deplate.variables["ps2imgRes"] || 96
+        r = args["rx"] || instance.deplate.variables["ps2imgRes"] || 120
         # r = args["rx"] || 140
         # case device
         # when "pdf"
         #     log_popen(instance, "#{get_app('ps2pdf'} #{psfile} #{outfile}")
         # else
         #     log_popen(instance, "#{get_app('ps2ppm'} -o -r #{r} -g -t -f #{device} #{psfile}")
-        #     log_popen(instance, "#{get_app('convert'} -antialias -density #{r}x#{r} #{psfile} #{outfile}")
+            # log_popen(instance, "#{get_app('convert')} -antialias -density #{r}x#{r} #{psfile} #{outfile}")
             Ps2ppm.run(psfile, "o" => true, "r" => r, "g" => true, "t" => true, "f" => device)
         # end
     end
 
+    def jave(instance, imgfile, args)
+        variables = args[:deplate].variables
+        cmd   = ["#{get_app('jave')} image2ascii #{imgfile}"]
+        alg   = args['ascii_algorithm'] || args['algorithm'] || 
+            variables['ascii_algorithm'] || 'edge_detection'
+        cmd << "algorithm=#{alg}"
+        width = args['ascii_width'] || args['width'] || variables['ascii_width']
+        if width =~ /^(\d+)%$/
+            width = 80 * $1.to_i / 100
+        elsif width =~ /^(\d+)cm$/
+            width = $1.to_i / 2
+        elsif width =~ /^(\d+)mm$/
+            width = $1.to_i / 20
+        elsif width =~ /^(\d+)px$/ or width.to_i > 120
+            width = $1.to_i / 8
+        elsif width =~ /^(\d+)pt$/
+            width = $1.to_i / 8
+        elsif width !~ /^(\d+)$/
+            width = nil
+        end
+        cmd << "width=#{width}" if width
+        log_popen(instance, cmd.join(' '))
+    end
+    
     def dot(instance, device, dotfile, outfile, command_line_args=[])
-        c = command_line_args.join(" ")
+        c = command_line_args.join(' ')
         log_popen(instance, "#{get_app('dot')} -T#{device} -o#{outfile} #{c} #{dotfile}")
     end
 

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

@@ -3,8 +3,8 @@
 # @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
+# @Last Change: 02-Apr-2006.
+# @Revision:    0.2125
 
 require "deplate/docbook"
 
@@ -26,7 +26,7 @@ class Deplate::Formatter::DbkRef < Deplate::Formatter::Docbook
         out = @deplate.variables["refentry"]
         unless out
             out = @deplate.options.out
-            out = File.basename(out, File.extname(out))
+            out = File.basename(out, '.*')
             @deplate.variables["refentry"] = out
         end
         o = []

data/lib/deplate/fmt/html.rb

@@ -3,9 +3,10 @@
 # @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
+# @Last Change: 05-Jun-2006.
+# @Revision:    0.4111
 
+# require 'cgi'
 require 'uri'
 require 'parsedate'
 require 'time'
@@ -16,9 +17,9 @@ require 'deplate/formatter'
 # A sample html formatter.
 
 class Deplate::Formatter::HTML < Deplate::Formatter
-    self.myname = "html"
+    self.myname = 'html'
     self.rx     = /html?/i
-    self.suffix = ".html"
+    self.suffix = '.html'
 
     self.label_delegate = [
         :format_heading,
@@ -37,7 +38,7 @@ class Deplate::Formatter::HTML < Deplate::Formatter
         :format_paragraph,
         :format_verbatim,
     ]
-        
+       
     attr_accessor :html_class
 
 
@@ -45,14 +46,16 @@ class Deplate::Formatter::HTML < Deplate::Formatter
     def initialize(deplate, args)
         super
         # Create OpenOffice compatible footnotes
-        @footnote_template = "sdfootnote%dsym"
-        @is_html_pageicons = false
+        @footnote_template    = 'sdfootnote%dsym'
+        @html_navigation_note = nil
+        @is_html_pageicons    = false
         @special_symbols = {
             %{"} => %{&quot;},
             %{>} => %{&gt;},
             %{<} => %{&lt;},
             %{&} => %{&amp;},
-            %{ } => lambda {|escaped| escaped ? "&nbsp;" : " "},
+            # %{�} => %{&euro;},
+            %{ } => lambda {|escaped| escaped ? '&nbsp;' : ' '},
         }
         build_plain_text_rx
         @encodings = {
@@ -63,29 +66,35 @@ class Deplate::Formatter::HTML < Deplate::Formatter
     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])
+                src = @deplate.collected_css[name]
+                if src
+                    css  = File.basename(src)
+                    dest = @deplate.auxiliary_filename(css, true)
+                    if anyway or !File.exist?(dest)
+                        @deplate.copy_file(src, dest)
+                    end
+                else
+                    srcc = @deplate.auxiliary_filename("#{name}.css", true)
+                    unless File.exist?(srcc)
+                        log(['File not found', srcc], :error)
+                    end
                 end
             rescue
-                log(["Can't copy css file", css], :error)
+                log(["Can't copy css file", name], :error)
             end
         end
     end
     
     def hook_pre_body_flush_html
-        url = @variables["baseUrl"]
+        url = @variables['baseUrl']
         if url
-            fn = @deplate.output.top_heading.destination || @deplate.options.out
-            if fn && fn != "-"
+            fn = output_destination
+            if fn && fn != '-'
                 fn  = Pathname.new(fn).expand_path
-                unless fn.dirname.to_s == "."
+                unless fn.dirname.to_s == '.'
                     pwd = Pathname.new(Dir.pwd).expand_path
-                    fn  = fn.relative_path_from(pwd).to_s.gsub(/\\/, "/")
-                    fp  = @variables["baseUrlStripDir"]
+                    fn  = fn.relative_path_from(pwd).to_s.gsub(/\\/, '/')
+                    fp  = @variables['baseUrlStripDir']
                     if fp
                         fn = fn.split(/\//)
                         fn = fn[fp.to_i..-1]
@@ -118,19 +127,19 @@ class Deplate::Formatter::HTML < Deplate::Formatter
     def prepare
         html_head
 
-        bodyOpts = @variables["bodyOptions"] || ""
+        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>")
+        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>")
+        output_at(:pre, :head_beg, '<head>')
 
-        t = @variables["encoding"] || "ISO-8859-1"
+        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))
@@ -146,9 +155,9 @@ class Deplate::Formatter::HTML < Deplate::Formatter
             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"
+            elsif !date.empty?
+                if date =~ /^(\w+)(\s+|-|\.|\/)(\d\d(\d\d))$/
+                    date = "1-#$1-#$3"
                 end
                 begin
                     date = ParseDate.parsedate(date, true)
@@ -159,14 +168,18 @@ class Deplate::Formatter::HTML < Deplate::Formatter
                 end
             end
         end
-        date ||= Time.now
-        # date   = date.xmlschema
-        date   = xmlschema(date)
+        if date == ''
+            date = nil
+        else
+            date ||= Time.now
+            # date   = date.xmlschema
+            date   = xmlschema(date)
+        end
             
-        title = @deplate.get_clip("title")
+        title = @deplate.get_clip('title')
         title = clean_tags(title.elt) if title
 
-        if @variables["useDublinCore"]
+        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
@@ -179,24 +192,24 @@ class Deplate::Formatter::HTML < Deplate::Formatter
         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="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, 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 = @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"]
+        styleExtra = @variables['styleExtra']
         if styleExtra
             styleExtra = styleExtra.join("\n") if styleExtra.kind_of?(Array)
             styleExtra = <<EOH
@@ -210,14 +223,20 @@ EOH
         end
 
         shortcutIcon = @variables["shortcutIcon"]
-        output_at(:pre, :head_end, head_link_tag(%{rel="shortcut icon" href="#{shortcutIcon}" type="image/x-icon"})) if shortcutIcon
+        if shortcutIcon
+            shortcutIcon = escape_filename(shortcutIcon)
+            output_at(:pre, :head_end, head_link_tag(%{rel="shortcut icon" href="#{shortcutIcon}" type="image/x-icon"}))
+        end
         pageicon = @variables["pageIcon"]
-        output_at(:pre, :head_end, head_link_tag(%{rel="icon" href="#{pageicon}" type="image/x-icon"})) if pageicon
+        if pageicon
+            pageicon = escape_filename(pageicon)
+            output_at(:pre, :head_end, head_link_tag(%{rel="icon" href="#{pageicon}" type="image/x-icon"}))
+        end
 
-        output_at(:pre, :html_relations, @deplate.invoke_service("navigation_links")) unless @variables["noPageNavigation"]
+        output_at(:pre, :html_relations, invoke_service('navigation_links')) unless @variables['noPageNavigation']
        
-        output_at(:pre, :head_end, @variables["explorerHack"])
-        output_at(:pre, :head_end, "</head>")
+        output_at(:pre, :head_end, @variables['explorerHack'])
+        output_at(:pre, :head_end, '</head>')
     end
 
     def head_meta_tag(text)
@@ -230,11 +249,11 @@ EOH
 
     def xmlschema(time)
         z = time.zone.scan(/([+-])(\d+):(\d+)/)[0]
-        z = z ? ("%s%02d:%02d" % z) : ""
+        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)
+            time.strftime('%Y-%m-%dT%H:%M:%S' + z)
         else
-            time.strftime("%Y-%m-%d")
+            time.strftime('%Y-%m-%d')
         end
     end
     private :xmlschema
@@ -253,7 +272,7 @@ EOH
             id  = use_id(args, opts)
             oid = opts['id']
             if oid and oid != id
-                log(['ID mismatch', id, oid, opts, args], :error)
+                invoker.log(['ID mismatch', id, oid, opts, args], :error)
             end
             opts['id'] = encode_id(id) if id
             # args = args.dup
@@ -268,7 +287,7 @@ EOH
         case cls
         when Array
             unless opts['class'].empty?
-                opts['class'] = opts['class'].join(' ')
+                opts['class'] = class_attr(opts['class'])
             end
         when nil
             opts['class'] = get_html_class(invoker)
@@ -279,23 +298,11 @@ EOH
             end
         end
         if single
-            opts << "/"
+            opts << '/'
         end
-        %{<%s>} % [tag, *opts].compact.join(" ")
+        %{<%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
@@ -304,76 +311,145 @@ EOH
         [open_tag(invoker, tag, opts), text, close_tag(invoker, tag)].join
     end
     
+    def wrap_formatted_particle_styles(invoker, value, args)
+        s = args[:styles]
+        unless !s or s.empty?
+            value.sub!(/\A(\s*)(.*?)(\s*)\Z/m) do |m|
+                %{#$1<span class="#{class_attr(s)}">#$2</span>#$3}
+            end
+        end
+        value
+    end
+
+    def wrap_formatted_element_styles(invoker, value, args)
+        s = args[:styles]
+        unless !s or s.empty?
+            value.sub!(/\A(\s*)(.*?)(\s*)\Z/m) do |m|
+                <<EOT
+#$1<div class="#{class_attr(s)}">
+#$2
+</div>#$3
+EOT
+            end
+        end
+        value
+    end
+
+    def wrap_formatted_element_zz_stepwise(invoker, value, args)
+        if @variables['stepwiseDisplay']
+            @deplate.output.attributes[:stepwiseIdx] ||= 0
+            idx = @deplate.output.attributes[:stepwiseIdx] += 1
+            beg = (@variables['stepwiseBegin'] || '1').to_i
+            vis = idx > beg ? 'hidden' : 'visible'
+            value.sub!(/\A(\s*)(.*?)(\s*)\Z/m) do |m|
+                <<EOT
+#$1<div id="Step#{idx}" style="visibility:#{vis};">
+#$2
+#$1</div>#$3
+EOT
+            end
+        end
+        value
+    end
+
     def wrap_text(text, args={})
         args[:check] ||= lambda do |line|
             line =~ /<[^>]*$/
         end
         super(text, args)
     end
-    
+   
+    def class_attr(classes)
+        classes.flatten.compact.uniq.join(' ')
+    end
+
     
     ################################################ Lists {{{1
-    def format_list_item(invoker, type, level, item, html_class=nil, explicit=false)
+    def format_list_item(invoker, type, level, item, args={})
         indent = format_indent(level, true)
         body = item.body
-        body = wrap_text(body) if body
-        opts = {"class" => []}
-        html_class ||= item.style || get_html_class(invoker)
+        opts = {'class' => []}
+        html_class ||= get_html_class(invoker, :add => item.style, :set => false)
         if html_class
-            opts["class"] << html_class
+            opts['class'] << html_class
         end
         case type
-        when "Numbered", "Itemize"
+        when 'Ordered', 'Itemize'
+            explicit = args[:explicit]
             ev = list_item_explicit_value(item, explicit)
             if ev
-                opts["value"] = ev
+                ev = ev.sub(/\.\s*$/, '')
+                if ev =~ /^([[:lower:]])$/
+                    ev = $1[0] - 96
+                elsif ev =~ /^([[:upper:]])$/
+                    ev = $1[0] - 64
+                end
+                opts['value'] = ev.to_s
             else
                 case item.item
-                when "-"
-                    opts["class"] << "dash"
-                when "+"
-                    opts["class"] << "plus"
-                when "*"
-                    opts["class"] << "asterisk"
-                when "�"
-                    opts["class"] << "bullet"
+                when '-'
+                    opts['class'] << 'dash'
+                when '+'
+                    opts['class'] << 'plus'
+                when '*'
+                    opts['class'] << 'asterisk'
+                when '�'
+                    opts['class'] << 'bullet'
                 end
             end
-            li = open_tag(invoker, "li", opts)
+            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)
+            body = indent_text(wrap_text(body), :mult => level + 1)
             return %{#{indent}#{li}\n#{body}}, %{#{indent}</li>}
-        when "Description"
-            dt = open_tag(invoker, "dt", opts)
-            dd = open_tag(invoker, "dd", opts)
+        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
+            accum << indent_text(wrap_text(body), :mult => 1) if body
+            return indent_text(accum.join, :mult => level), "#{indent}</dd>"
+        when 'Task'
+            pri  = item.opts[:priority]
+            cat  = item.opts[:category]
+            done = item.opts[:done] ? 'done' : nil
+            due  = item.opts[:due]
+            opts = {}
+            cls  = cat ? [html_class, cat].join('-') : html_class
+            opts['class'] = class_attr([cls, done])
+            li   = open_tag(invoker, 'li', opts)
+            task = [cat, pri].compact.join
+            task += " #{due}" if due
+            body = [%{<span class="#{cls}">#{task}</span>}, body].join(' ')
+            body = indent_text(wrap_text(body), :mult => level + 1)
+            return %{#{indent}#{li}\n#{body}}, %{#{indent}</li>}
+        when 'Paragraph'
+            body = wrap_text(body)
+            body = %{<br class="itempara" />#{body}} unless args[:follow_container]
+            return indent_text(body, :mult => 2), nil
+        when 'Container'
+            return body, nil
         else
-            raise "Unknown list type: #{item.inspect}"
+            invoker.log(['Unknown list type', type], :error)
         end
     end
     
     def format_list_env(invoker, type, level, what, subtype=nil)
         indent = format_indent(level)
         opts   = {'class' => []}
-        html_class ||= get_html_class(invoker)
+        html_class ||= get_html_class(invoker, :add => type, :set => false)
         if html_class
-            opts["class"] << html_class
+            opts['class'] << html_class
         end
         case type
-        when "Numbered"
+        when 'Ordered'
             case subtype
-            when "a"
-                opts["type"] = "a"
+            when 'a'
+                opts['type'] = 'a'
                 opts['class'] << 'alpha'
-            when "A"
-                opts["type"] = "A"
+            when 'A'
+                opts['type'] = 'A'
                 opts['class'] << 'Alpha'
             # when "1"
             #     type = %{}
@@ -381,13 +457,16 @@ EOH
                 opts['class'] << 'numeric'
             #     type = %{}
             end
-            tag = "ol"
-        when "Itemize"
-            tag = "ul"
-        when "Description"
-            tag = "dl"
+            tag = 'ol'
+        when 'Itemize'
+            tag = 'ul'
+        when 'Task'
+            tag = 'ul'
+            opts['class'] << 'Task'
+        when 'Description'
+            tag = 'dl'
         else
-            raise "Unknown list type: #{type}"
+            invoker.log(['Unknown list type', type], :error)
         end
         
         case what
@@ -408,24 +487,35 @@ EOH
         end
     end
 
-    def get_html_class(invoker, default=nil)
-        html_class = [
-            invoker.args["htmlClass"],
-            invoker.styles_as_string,
-        ]
-        html_class.compact!
+    def get_html_class(invoker, args={})
         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
+            html_class = invoker.html_class
+        else
+            html_class = nil
+        end
+        unless html_class
+            default    = args[:default]
+            html_class = [
+                invoker.args[:htmlClass],
+                invoker.args['htmlClass'],
+                invoker.styles_as_string,
+                args[:style],
+                args[:html_class],
+                (args[:add] || []),
+            ]
+            html_class.flatten!
+            html_class.compact!
             if html_class.empty?
-                html_class << invoker.html_class
+                html_class = default
+            else
+                html_class.uniq!
+                html_class = class_attr(html_class)
+            end
+            if invoker.respond_to?(:html_class=) and args[:set] != false
+                invoker.html_class = html_class
             end
         end
-        html_class.compact!
-        return html_class.empty? ? nil : html_class.join(" ")
+        return html_class
     end
     
     def format_label(invoker, mode=nil, label=nil, with_id=true)
@@ -442,7 +532,7 @@ EOH
             when :after
                 for l in label
                     if @open_labels.delete(l)
-                        accum << "</a>"
+                        accum << '</a>'
                     end
                 end
             when :closeOpen
@@ -453,7 +543,7 @@ EOH
             # when :once
             else
                 for l in label
-                    text = if block_given? then yield(l) else "" end
+                    text = if block_given? then yield(l) else '' end
                     accum << %{<a name="#{l}"></a>#{text}}
                 end
             end
@@ -464,10 +554,10 @@ EOH
     def format_figure(invoker, inline=false, elt=nil)
         elt ||= invoker.elt
         if inline
-            include_image(elt, invoker.args)
+            include_image(invoker, elt, invoker.args)
         else
             acc = []
-            fig     = @deplate.msg("Figure")
+            fig     = @deplate.msg('Figure')
             caption = invoker.caption
             if caption
                 capAbove = !(caption && caption.args && caption.args.include?("below"))
@@ -483,7 +573,7 @@ EOH
             if caption and capAbove
                 acc << cap
             end
-            acc << include_image(elt, invoker.args)
+            acc << include_image(invoker, elt, invoker.args)
             if caption and !capAbove
                 acc << cap
             end
@@ -492,60 +582,119 @@ EOH
         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"]
+    def include_image(invoker, file, args, inline=false)
+        acc  = []
+       
+        file = args['file'] if args['file']
+        file = img_url(use_image_filename(file, args))
+        acc << %{src="#{file}"}
+        
+        w = args['w'] || args['width']
+        acc << %{width="#{w}"} if w
+        h = args['h'] || args['heigth']
+        acc << %{height="#{h}"} if h
+       
+        # b = args['border'] || '0'
+        # acc << %{border="#{b}"}
+        
+        # f = file[0..-(File.extname(file).size + 1)]
+        alt = args['alt']
         if alt
             alt.gsub!(/[\\"&<>]/) do |s|
                 case s
                 when '\\'
-                    '\\\\'
+                    ''
                 else
-                    plain_text(s)
+                    plain_text(s).gsub(/\\([0-9&`'+])/, '\\1')
                 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}" />}
+        acc << %{alt="#{alt}"}
+        
+        style = args['style']
+        if style
+            style = style.split(/[ ,]/)
+        else
+            style = []
+        end
+        style << (inline ? 'inline' : 'figure')
+        acc << %{class="#{class_attr(style)}"}
+
+        img_id = args['id']
+        unless img_id
+            fbase  = Deplate::Core.clean_file_name(File.basename(fbase || 'imgid'))
+            img_id = @deplate.auto_numbered(fbase, :inc => 1, :fmt => %{#{fbase}_%s})
+        end
+        acc << %{id="#{img_id}" name="#{img_id}"}
+
+        hi = args['hi']
+        if hi
+            case hi
+            when String
+                hi_img = img_url(use_image_filename(hi, args))
+            else
+                hi_img = [File.dirname(file), %{hi-#{File.basename(file)}}]
+                hi_img = File.join(hi_img.compact)
             end
+            
+            setup_highlight_image
+            acc << %{onMouseover="HighlightImage('%s', '%s')" onMouseout="HighlightImage('%s', '%s')"} % [
+                img_id, img_url(hi_img, args), 
+                img_id, file
+            ]
         end
-        return %{<img src="#{file}" alt="#{alt}" class="#{style}" />}
+        
+        return %{<img #{acc.join(' ')}/>}
     end
 
+    def setup_highlight_image
+        unless @deplate.options.highlight_image
+            output_at(:pre, :javascript, <<EOJS
+<script type="text/javascript">
+<!--
+    function HighlightImage(Name, Src) {
+        if (document.images) {
+            document.images[Name].src = Src
+        }
+    }
+//-->
+</script>
+EOJS
+                     )
+            @deplate.options.highlight_image = true
+        end
+    end
+
+    def img_url(file, args={})
+        if args[:raw]
+            file
+        else
+            fmt  = @deplate.variables['htmlImgUrl'] || @deplate.variables['htmlAuxUrl']
+            fmt ? fmt % file : file
+        end
+    end
+    
     def image_suffixes
-        [".png", ".jpeg", ".jpg", ".gif", ".bmp"]
+        ['.png', '.jpeg', '.jpg', '.gif', '.bmp', '.wmf']
     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"
+        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"
+            invoker.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"])
@@ -556,19 +705,18 @@ EOH
         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"
+        capAbove   = !(caption && caption.args && caption.args.include?('below'))
+        style      = invoker.styles_as_string || @variables['tableStyle']
+        style.gsub!(/[,;]+/, ' ') if style
+        clss       = style || get_html_class(invoker, :default => 'standard')
         clsss      = %{ class="#{clss}"}
         opts       = format_particle(:table_args, invoker)
-        halfindent = "  "
+        halfindent = '  '
         indent     = halfindent * 2
        
         acc = []
         unless args[:dontWrapTable]
-            acc << %{<div class="#{['table', style].compact.join(' ')}">}
+            acc << %{<div class="#{class_attr(['table', style])}">}
         end
         acc << %{<table#{clsss}#{opts}>}
         if caption
@@ -580,7 +728,7 @@ EOH
             end
             # capOpts << %{style="text-align=#{float_align_caption(invoker)};"}
             cap = %{#{@deplate.msg("Table")} #{level_as_string}: #{caption.elt}}
-            acc << %{<caption#{capOpts.join(" ")}>#{cap}</caption>}
+            acc << %{<caption#{capOpts.join(' ')}>#{cap}</caption>}
         end
       
         acc_head = []
@@ -588,17 +736,17 @@ EOH
         acc_body = []
         elt.each_with_index do |r, n|
             if r.head
-                row = formatted_table_row(n, r, args, indent, clss, "th")
+                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")
+                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")
+                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
@@ -619,8 +767,8 @@ EOH
         end
         acc << acc_body
 
-        acc << "</table>"
-        note = invoker.args["note"]
+        acc << '</table>'
+        note = invoker.args['note']
         if note
             note  = @deplate.parse_and_format(invoker, note)
             nopts = ['', %{class="tableNote"}]
@@ -629,14 +777,18 @@ EOH
             acc   << %{<div#{nopts.join(' ')}>#{note}</div>}
         end
         acc << "</div>\n" unless args[:dontWrapTable]
-        acc << ""
+        acc << ''
 
         join_blocks(acc)
     end
 
+    # def table_empty_cell
+    #     '{ins: &nbsp}'
+    # end
+    
     def table_add_row(acc, row, clss, args)
-        tag       = args[:tag]    || "tr"
-        indent    = args[:indent] || "  "
+        tag       = args[:tag]    || 'tr'
+        indent    = args[:indent] || '  '
         dblindent = indent * 2
         row = row.join("\n#{dblindent}")
         acc << %{#{indent}<#{tag} class="#{clss}">}
@@ -644,11 +796,11 @@ EOH
         acc << "#{indent}</#{tag}>"
     end
 
-    def format_heading(invoker)
-        l         = format_label(invoker, nil, nil, false)
-        level     = invoker.level
+    def format_heading(invoker, level=nil, elt=nil)
         args      = invoker.args
-        elt       = invoker.elt
+        level   ||= invoker.level
+        elt     ||= invoker.elt
+        l         = format_label(invoker, nil, nil, false)
         html_args = invoker.html_args || ''
         id        = invoker.get_id
         if consume_label(id)
@@ -657,9 +809,10 @@ EOH
         if level > 0 and level <= 6
             hd = "h#{level}"
             if invoker.plain_caption?
-                ls = ""
+                ls = ''
             else
-                ls = invoker.level_as_string + "&nbsp;"
+                ls  = invoker.level_as_string
+                ls += '&nbsp;' if ls
             end
             %{\n<#{hd}#{html_args}>#{l}#{ls}#{elt}</#{hd}>\n}
         else
@@ -673,7 +826,7 @@ EOH
     end
 
     def format_break(invoker)
-        format_pagebreak(invoker, "break")
+        format_pagebreak(invoker, 'break')
     end
 
     def format_anchor(invoker)
@@ -692,28 +845,34 @@ EOH
     ################################################ Regions {{{1
     def format_verbatim(invoker, text=nil)
         text ||= invoker.elt
-        format_environment(invoker, "pre", {"class"=>"verbatim"}, plain_text(text, :pre))
+        format_environment(invoker, 'pre', {'class'=>'verbatim'}, plain_text(text, :pre))
     end
 
     def format_abstract(invoker)
-        format_environment(invoker, %{blockquote}, {"class"=>"abstract"}, invoker.elt)
+        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)
+        elt = invoker.elt.strip
+        rv  = [if invoker.args['long']
+                  format_environment(invoker, %{blockquote}, {'class'=>'longquote'}, elt)
+              else
+                  format_environment(invoker, %{blockquote}, {'class'=>'quote'}, elt)
+              end]
+        if (src = invoker.args['source'])
+            rv << format_environment(invoker, %{div}, {'class' => 'source'},
+                                     plain_text(src))
         end
+        join_blocks(rv)
     end
 
     def format_header(invoker)
-        format_header_or_footer(invoker, :pre, :header, "HEADER", "header")
+        format_header_or_footer(invoker, :pre, :header, 'HEADER', 'header')
         nil
     end
 
     def format_footer(invoker)
-        format_header_or_footer(invoker, :post, :footer, "FOOTER", "footer")
+        format_header_or_footer(invoker, :post, :footer, 'FOOTER', 'footer')
         nil
     end
 
@@ -730,7 +889,7 @@ EOH
             acc << c % ii.elt if ii
         end
         acc << %{</div>}
-        acc << format_pagebreak(invoker, "title") if invoker.args["page"]
+        acc << format_pagebreak(invoker, 'title') if invoker.args['page']
         join_blocks(acc)
     end
 
@@ -761,28 +920,33 @@ EOH
 
 
     ################################################ Particles {{{1
-    def format_emphasize(invoker, text)
-        inline_tag(invoker, "em", text)
+    def format_emphasize(invoker, text=nil)
+        text ||= invoker.elt || invoker.text
+        inline_tag(invoker, 'em', text)
     end
     
-    def format_code(invoker, text)
-        inline_tag(invoker, "code", plain_text(text, :code))
+    def format_code(invoker, text=nil)
+        text ||= invoker.elt || 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))
+        dest.gsub!(/&/, '&amp;')
+        if name =~ /^mailto:(.*)$/
+            name = $1
+        end
+        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))
+        inline_tag(invoker, 'a', name, href_args(invoker, dest))
     end
    
     def href_args(invoker, dest)
-        args = {"href" => dest}
+        args = {'href' => dest}
         target = invoker.args['target']
         if target
             args['target'] = target
@@ -793,29 +957,29 @@ EOH
     
     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 "+++", "###", "???", "!!!"
+        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 "<~"
@@ -830,19 +994,19 @@ EOH
     end
 
     def doublequote_open(invoker)
-        "&ldquo;"
+        '&ldquo;'
     end
     
     def doublequote_close(invoker)
-        "&rdquo;"
+        '&rdquo;'
     end
     
     def singlequote_open(invoker)
-        "&lsquo;"
+        '&lsquo;'
     end
     
     def singlequote_close(invoker)
-        "&rsquo;"
+        '&rsquo;'
     end
 
     
@@ -851,45 +1015,53 @@ EOH
         if idx
             return format_label(invoker, :string, [idx.label])
         else
-            return ""
+            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 elt and elt.elt and elt.fn_consumed
+            lab = elt.fn_label
             if !@deplate.footnotes_used.include?(lab)
                 idx      = @deplate.footnote_last_idx +=1
-                hclass   = "sdfootnoteanc"
-                id       = "sdfootnote%d"    % idx
-                name     = "sdfootnote%danc" % idx
+                hclass   = 'sdfootnoteanc'
+                id       = 'sdfootnote%d'    % idx
+                name     = 'sdfootnote%danc' % idx
                 href     = @footnote_template % idx
                 lab      = [href]
-                fn.n     = idx
-                fn.label = lab
+                elt.fn_n  = idx
+                elt.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>}]
+                    t = [
+                        %{<div id="#{id}">},
+                    ]
+                    l = %{<a class="sdfootnotesym" name="#{href}" href="##{name}">#{idx}</a>}
+                    e = elt.elt[0]
+                    case e
+                    when Deplate::Element::Paragraph
+                        e.elt.insert(0, l)
+                    else
+                        t << l
+                    end
+                    elt.push_styles('sdfootnote')
+                    t << elt.format_current
+                    t << %{</div>}
                     output_at(:body, :footnotes, t.join("\n"))
                 end
             else
-                href = @footnote_template % fn.n
+                href = @footnote_template % elt.fn_n
             end
-            return %{<a class="sdfootnoteanc" name="#{name}" href="##{href}">#{fn.n}</a>}
+            return %{<a class="sdfootnoteanc" name="#{name}" href="##{href}">#{elt.fn_n}</a>}
         else
-            return ""
+            return ''
         end
     end
 
     def format_ref(invoker)
-        text = invoker.text || ""
+        text = invoker.text || ''
         f = @deplate.get_filename_for_label(invoker, text)
         if f
             # if invoker.args['obj'] and (o = @deplate.label_aliases[text])
@@ -902,74 +1074,31 @@ EOH
             if l
                 t = plain_text(l)
             else
-                t = @variables["refButton"] || "[&rArr;]"
+                t = @variables['refButton'] || '[&rArr;]'
             end
-            return %{&nbsp;<a href="#{URI.escape(f)}##{URI.escape(text)}" class="ref">#{t}</a>}
+            prefix = invoker.args['prefix'] || '&nbsp;'
+            return %{#{prefix}<a href="#{URI.escape(f)}##{URI.escape(text)}" class="ref">#{t}</a>}
+        else
+            return text.empty? ? '??' : text
         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
+        open_tag(invoker, 'br', nil, :single => true)
+    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) : ""
+        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)
+        inline_tag(invoker, 'sub', invoker.elt)
     end
 
     def format_superscript(invoker)
-        inline_tag(invoker, "sup", invoker.elt)
+        inline_tag(invoker, 'sup', invoker.elt)
     end
 
     # this doesn't work with IExplorer and others
@@ -982,7 +1111,7 @@ EOH
     end
 
     def format_pagenumber(invoker)
-        return ""
+        return ''
     end
 
 
@@ -1015,15 +1144,15 @@ EOH
 
     ################################################ Head {{{1
     def head_css
-        csso = @variables["css"]
+        csso = @variables['css']
         if csso
             csss = csso.split(/\s+/)
         else
             csss = []
         end
-        cls = @variables["class"]
+        cls = @variables['class']
         if cls
-            csss << cls + ".css"
+            csss << cls + '.css'
         end
         acc = []
         csss.each_with_index do | f, i |
@@ -1034,14 +1163,19 @@ EOH
             else
                 with_title = true
             end
-            cssName = File.basename(css, ".css")
+            cssName = File.basename(css, '.css')
+            unless @deplate.options.css.find {|c, anyway| cssName == c}
+                @deplate.options.css << [cssName]
+            end
             cssFile = @deplate.auxiliary_filename(css)
+            cssFmt  = @deplate.variables['htmlCssUrl'] || @deplate.variables['htmlAuxUrl']
+            cssFile = cssFmt % cssFile if cssFmt
             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(" "))
+            acc << head_link_tag(opts.join(' '))
         end
-        cssExtra = @variables["cssExtra"]
+        cssExtra = @variables['cssExtra']
         acc << cssExtra if cssExtra
         return acc.join("\n")
     end
@@ -1060,132 +1194,102 @@ EOH
     def html_def
         acc = []
         acc << html_lang
-        acc << @variables["htmlDefEtc"] if @variables["htmlDefEtc"]
+        acc << @variables['htmlDefEtc'] if @variables['htmlDefEtc']
         if acc.empty?
-            return "<html>"
+            return '<html>'
         else
-            return "<html #{acc.join(" ")}>"
+            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")
+    def format_list_of_toc(invoker)
+        format_list_of(invoker, 
+                       :title => 'Table of Contents',
+                       :prefix => 'hd', 
+                       :listing => 'toc', 
+                       :flat => false, 
+                       :style => '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"]
+        data = @deplate.options.listings.get('toc').find_all {|e| e.level == 1}
+        format_list_of(invoker, 
+                       :title => 'Contents', 
+                       :prefix => 'hd', 
+                       :data => data, :flat => false, 
+                       :img => @variables['navGif'],
+                       :style => '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")
+    def format_list_of_lot(invoker)
+        format_list_of(invoker, 
+                       :title => 'List of Tables', 
+                       :prefix => 'tab', 
+                       :listing => 'lot',
+                       :flat => true,
+                       :style => '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")
+    def format_list_of_lof(invoker)
+        # @html_class = "lof"
+        format_list_of(invoker, 
+                       :title => 'List of Figures', 
+                       :prefix => 'fig', 
+                       :listing => 'lof', 
+                       :flat => true, 
+                       :style => 'lof')
     end
 
     def format_list_of_index(invoker)
-        format_the_index(invoker, "Index", @deplate.index, "idx", 
-                         true, :html_class => "index")
+        format_the_index(invoker, 'Index', 
+                         @deplate.index, 
+                         'idx', 
+                         true, 
+                         :style => 'index')
+    end
+
+    def listing_prematter(invoker, args, id)
+        img = args[:img]
+        img = %{<img src="#{img_url(img, args)}" border="0" alt="" />} if img
+        %{<div id="%s">%s\n<div id="%sBlock" class="%s">} % [
+            id,
+            img,
+            id,
+            get_html_class(invoker, args)
+        ]
     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)}\./
+    
+    def listing_postmatter(invoker, args)
+        %{</div></div>}
+    end
+    
+    def listing_title(invoker, args, name)
+        if name
+            %{<h1 class="%s">%s%s</h1>} % [
+                get_html_class(invoker, args), 
+                format_label(invoker), 
+                @deplate.msg(name)
+            ]
         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"
+    
+    def listing_item(invoker, args, prefix, title, heading, level, other_args)
+        v = clean_tags(title)
+        v = [heading.level_as_string, v].join(' ') unless heading.plain_caption?
+        f = heading.output_file_name(:relative => invoker)
+        d = [f, @deplate.elt_label(prefix, heading.level_as_string)].join('#')
+        b = format_url(invoker, v, d, nil, true)
+        s = Deplate::ListItem.new(nil, b, 'Itemize', 'Itemize', level, 0, true)
+        s.style = get_html_class(invoker, args)
+        s
+    end
+    
+    def format_the_index(invoker, name, data, prefix='', flat=false, other_args={})
+        style  = other_args[:style] || 'index'
         accum  = []
         chars  = []
         
@@ -1196,41 +1300,43 @@ EOH
                 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 << %{<h2 class="%s">%s%s</h2>} % [style, 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)
+                xf = i.file(invoker)
+                xl = i.level_as_string
+                if xf or xl
+                    f = xf || invoker.output_file_name(:level_as_string => xl, 
+                                                       :relative => invoker)
                     if f == ff
-                        f = ""
-                        l = i.level_as_string
+                        f = ''
+                        l = xl
                         if l and !l.empty?
                             t = l
                         elsif @deplate.options.multi_file_output
-                            t = @variables["refButton"] || "[&rArr;]"
+                            t = @variables['refButton'] || '[&rArr;]'
                         else
-                            t = "I"
+                            t = 'I'
                         end
                     else
-                        t = @deplate.file_with_suffix(f, "", true)
+                        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)
+                    invoker.log(['Index: Neither file nor level defined: dropping', n, 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)
+            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)
+        accum << format_list_env(invoker, 'Description', 0, :close)
 
         acc = []
-        acc << %{<p class="%stoc">} % html_class
+        acc << %{<p class="%stoc">} % style
         for c in chars
             l = format_url(invoker, c, "", format_index_hd_label(c), true)
             acc << l
@@ -1256,21 +1362,21 @@ EOH
         opts    = [nil]
         align   = float_align(invoker)
         case align
-        when "center"
-        when "right"
-        when "left"
+        when 'center'
+        when 'right'
+        when 'left'
         end
         opts << %{align="#{align}"} if align
-        width = args["width"] || @variables["tableWidth"]
+        width = args['width'] || @variables['tableWidth']
         opts << %{width="#{width}"} if width
         opts << %{summary="#{caption.elt}"} if caption and caption.elt
-        return opts.join(" ")
+        return opts.join(' ')
     end
 
     def float_align(invoker)
         args = invoker.args
-        args["align"] || @variables["floatAlign"]
-        # || "center"
+        args['align'] || @variables['floatAlign']
+        # || 'center'
     end
 
     def float_align_caption(invoker)
@@ -1284,9 +1390,9 @@ EOH
     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")
+        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
@@ -1299,9 +1405,9 @@ EOH
                     tag = thistag
                 else
                     if row.head
-                        tag = "th"
+                        tag = 'th'
                     else
-                        tag = "td"
+                        tag = 'td'
                     end
                 end
 
@@ -1333,7 +1439,7 @@ EOH
                 if styles.empty?
                     styles = ""
                 else
-                    opts << %{style="%s"} % styles.join("; ")
+                    opts << %{style="%s"} % styles.join('; ')
                 end
 
                 if cell.span_x > 1
@@ -1344,7 +1450,7 @@ EOH
                 end
 
                 # t << "<#{tag}#{opts.join(" ")}>#{indented(c, indent)}\n#{indent}</#{tag}>"
-                t << "<#{tag}#{opts.join(" ")}>#{c}</#{tag}>"
+                t << "<#{tag}#{opts.join(' ')}>#{c}</#{tag}>"
             end
         end
         t
@@ -1359,7 +1465,7 @@ EOH
 
     public
     ################################################ navigation bar {{{1
-    def format_navigation_bar(invoker, type, slot, bartype, first=false, last=false)
+    def format_navigation_bar(invoker, type, slot, bartype, first=nil, last=nil)
         idx, first, last = navbar_output_index(invoker, first, last)
 
         nomenu    = invoker.args['noNavMenu'] || @variables['noNavMenu']
@@ -1392,76 +1498,85 @@ EOH
                     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}, ""))
+                unless bartype == :inline or @variables['noBindKeys']
+                    output_at(:body, :navbar_js, invoke_service('navigation_keys', 'next' => urlspace))
                 end
             else
-                if (first or idx == 0) and !@variables["noNavigationNote"]
-                    output_at(type, slot, @deplate.invoke_service("navigation_note"))
+                if (first or idx == 0) and !@variables['noNavigationNote']
+                    output_at(type, slot, invoke_service('navigation_note'))
                 end
             end
         end
         navbar_end(type, slot, idx)
     end
 
+    def format_navigation_buttons(invoker, type, slot, bartype, first=false, last=false)
+        idx, first, last = navbar_output_index(invoker, first, last)
+        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)
+        output_at(type, slot, [urlp, url, urln].join)
+    end
+    
     def navbar_button_prev(type, slot, idx, bartype, ok)
         if ok
-            text = @variables["prevButton"] || @deplate.formatter.plain_text("<<")
+            text = @variables['prevButton'] || 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>}
+            ak   = bartype == :top ? %{ accesskey="B"} : ''
+            prv  = %{<a class="navbarUrl" title="Previous" href="#{urlp}"#{ak}>#{text}</a>}
         else
             urlp = nil
         end
         unless urlp
-            prv  = "&nbsp;"
+            prv  = '&nbsp;'
         end
-        navbar_add_element(type, slot, idx, prv, "navbar")
+        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"
+        if ok or @variables['homeShowAlways']
+            text = @variables['homeButton'] || '[-]'
+            url  = navbar_guess_file_name(@deplate.home_index, 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;"
+            home = '&nbsp;'
         end
-        navbar_add_element(type, slot, idx, home, "navbar")
+        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(">>")
+            text = @variables['nextButton'] || plain_text('>>')
             urln = navbar_guess_file_name(idx + 1, idx, bartype)
-            ak   = bartype == :top ? %{ accesskey="N"} : ""
+            ak   = bartype == :top ? %{ accesskey='N'} : ''
             nxt  = %{<a class="navbarUrl" title="Next" href="#{urln}"#{ak}>#{text}</a>}
         else
             urln = nil
         end
         unless urln
-            nxt  = "&nbsp;"
+            nxt  = '&nbsp;'
         end
-        navbar_add_element(type, slot, idx, nxt, "navbar")
+        navbar_add_element(type, slot, idx, nxt, 'navbar')
         return urln, nxt
     end
     
     def navbar_menu(type, slot, idx, bartype)
-        unless @deplate.options.navmenu
+        # 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
+            @variables['@contents'] ||= acc
+            th = @deplate.output.top_heading
             @deplate.each_heading(:top) do |hd, title|
                 file = hd.output_file_name(:basename => true)
                 unless hd.kind_of?(Deplate::NullTop)
@@ -1471,7 +1586,16 @@ EOH
                     end
                     acc << [title, file]
                 end
-                navmenu << %{<option value="#{file}">#{title}</option>}
+                pre = (hd.level and hd.level > 1) ? ('&nbsp;' * hd.level) : nil
+                o = []
+                o << 'selected' if hd == th
+                if o.empty?
+                    o = nil
+                else
+                    o << nil unless o.empty?
+                    o = o.join(' ')
+                end
+                navmenu << %{<option #{o}value="#{file}">#{pre}#{title}</option>}
             end
 
             navmenu << %{</select>}
@@ -1480,8 +1604,8 @@ EOH
             # navmenu << %{</button>}
             navmenu << %{</form>}
             @deplate.options.navmenu = navmenu.join("\n")
-        end
-        navbar_add_element(type, slot, idx, @deplate.options.navmenu, "navmenu")
+        # end
+        navbar_add_element(type, slot, idx, @deplate.options.navmenu, 'navmenu')
     end
     
     
@@ -1489,88 +1613,56 @@ EOH
     def format_navigation_links(depth)
         acc = []
         start = navbar_guess_file_name(0, nil, :inline)
-        if start and start != ""
-            title = @deplate.msg("Frontpage")
+        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|
+        tags = ['', 'chapter', 'section', 'subsection']
+        @deplate.each_heading(depth || @deplate.options.split_level) 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
+            file   = escape_filename(file)
+            file   = [file, '#', anchor].join if anchor
             acc << head_link_tag(%{rel="#{ref}" href="#{file}" title="#{clean_tags(title)}"})
         end
         acc.join("\n")
     end
+   
+    def escape_filename(fname)
+        fname.split(/\//).collect {|p| URI.escape(p)}.join('/')
+    end
     
-    def navbar_guess_file_name(idx, base, bartype, section=nil)
+    def navbar_guess_file_name(idx, base=nil, bartype=nil, section=nil)
         b  = @deplate.output_filename_by_idx(base)
         ff = @deplate.output_filename_by_idx(idx)
         f  = @deplate.relative_path_by_file(ff, b)
+        f  = escape_filename(f)
         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
+                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
+    def handle_key(key, function)
+        key = ',%s,' % key.split(/\s*,\s*/).join(',')
+        @deplate.output.attributes[:handle_keys] ||= {}
+        @deplate.output.attributes[:handle_keys][key] = function
     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"]
+    def_service('navigation_links') do |args, text|
+        depth = args['depth']
         depth &&= depth.to_i
-        @formatter.format_navigation_links(depth)
+        format_navigation_links(depth)
     end
 
-    def html_navigation_bar(args, text)
+    def_service('navigation_bar') do |args, text|
         type = :array
         slot = []
         invoker = args[:invoker]
@@ -1579,7 +1671,14 @@ class Deplate::Core
         else
             invoker = Deplate::PseudoContainer.new(@deplate, :args => args)
         end
-        @formatter.format_navigation_bar(invoker, type, slot, :inline)
+        bartype = if args['top']
+                      :top
+                  elsif args['bottom']
+                      :bottom
+                  else
+                      :inline
+                  end
+        format_navigation_bar(invoker, type, slot, bartype)
         slot.join("\n")
     end
 
@@ -1589,49 +1688,133 @@ class Deplate::Core
     # 16 ... shift
     # 17 ... ctrl
     # 18 ... alt
+    # 19 ... pause
     # 27 ... esc
     # 32 ... space
+    # 33 ... page up
+    # 34 ... page down
     # 37 ... left
     # 39 ... right
     # 78 ... n
+    # 109 ... -
+    # 112 ... F1
+    # ..
+    # 121 ... F10
+    # 188 ... ,
+    # 190 ... .
     # 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
+    def_service('navigation_keys') do |args, text|
+        urln = args['next']
+        if urln
+            last = false
+        else
+            idx, first, last = navbar_output_index(args[:invoker])
+            urln = navbar_guess_file_name(idx + 1, idx)
+        end
+        # prevKey = @variables['prevKey'] || '8'
+        acc = []
+        if urln and !last
+            nextKey = @variables['nextKey'] || '16'
+            handle_key(nextKey, 'NavigationNextPage();') if nextKey.to_i > 0
+            acc << <<EOJS
+<script type="text/javascript">
+    <!--
+        function NavigationNextPage() {
+            window.location="#{urln}";
+        }
+    //-->
+</script>
+EOJS
         end
         acc.join
     end
+   
+    def_service('navigation_handle_keys') do |args, text|
+        keys = @deplate.output.attributes[:handle_keys]
+        if keys
+            acc = [<<EOJS
+<script type="text/javascript">
+    <!--
+        function HandleKeys() {
+            this.event = function(e) {
+                if (!e) { e = window.event; }
+EOJS
+            ]
+            cmd = nil
+            keys.each do |key, fn|
+                cmd = cmd ? '} else if' : 'if'
+                acc << <<EOJS
+                #{cmd} ("#{key}".indexOf(","+ e.keyCode +",") != -1) {
+                    #{fn}
+EOJS
+            end
+            #     } else {
+            #         alert('DBG key code='+ e.keyCode);
+            acc << <<EOJS
+                }
+            };
+            var self = this;
+        }
+        var k = new HandleKeys();
+        document.onkeydown = k.event;
+    //-->
+</script>
+EOJS
+            acc.join
+        else
+            ''
+        end
+    end
     
-    def html_navigation_note(args, text)
+    def_service('stepwise_display') do |args, text|
+        stepKey = @variables['stepwiseKey'] || '34'
+        if @variables['stepwiseDisplay'] and stepKey
+            handle_key(stepKey, 'StepwiseDisplayNext();')
+            stepInit = @variables['stepwiseBegin'] || '1'
+            acc = []
+            acc << <<EOJS
+<script type="text/javascript">
+    <!--
+        var StepwiseCounter = #{stepInit};
+        function StepwiseDisplayNext() {
+            StepwiseCounter = StepwiseCounter + 1;
+            var Elt = document.getElementById('Step' + StepwiseCounter);
+            if (Elt)
+                Elt.style.visibility = 'visible';
+EOJS
+            if @variables['stepwiseContinous']
+            acc << <<EOJS
+            else
+                NavigationNextPage();
+EOJS
+            end
+            acc << <<EOJS
+        }
+        //-->
+    </script>
+EOJS
+            acc.join
+        else
+            ''
+        end
+    end
+
+    def_service('navigation_buttons') do |args, text|
+        type = :array
+        slot = []
+        invoker = args[:invoker]
+        if invoker
+            invoker.args.update(args)
+        else
+            invoker = Deplate::PseudoContainer.new(self, :args => args)
+        end
+        format_navigation_buttons(invoker, type, slot, :inline)
+        slot.join("\n")
+    end
+
+    def_service('navigation_note') do |args, text|
         unless @html_navigation_note
-            @html_navigation_note   = msg(:htmlnavigation_note)
+            @html_navigation_note   = @deplate.msg(:htmlnavigation_note)
             unless @html_navigation_note
                 @html_navigation_note = [
                     %{<p class="htmlnavigationnote" />},
@@ -1651,12 +1834,64 @@ class Deplate::Core
                 ].join("\n")
             end
         end
-        return @html_navigation_note
+        @html_navigation_note
+    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
+
+    # Return [idx, first, last]
+    def navbar_output_index(invoker, first=nil, last=nil)
+        acc = []
+        if invoker.respond_to?(:top_heading) and !invoker.kind_of?(Deplate::PseudoContainer)
+            th = invoker.top_heading
+        else
+            th  = @deplate.output.top_heading
+        end
+        if th
+            idx = @deplate.output_index(th)
+        end
+        acc << idx
+        gf = th.first_top
+        gl = th.last_top
+        # else
+        #     out = @deplate.output
+        #     acc << idx
+        #     gf = (idx == @deplate.home_index)
+        #     gl = (idx == @deplate.top_heading_idx)
+        # end
+        case first
+        when true, false
+            acc << first
+        else
+            acc << gf
+        end
+        case last
+        when true, false
+            acc << last
+        else
+            acc << gl
+        end
+        return acc
+    end
+
 end
 
 
-class Deplate::Element
+class Deplate::Base
     attr_accessor :html_class, :html_args
 
     def hook_pre_setup_html
@@ -1692,5 +1927,3 @@ class Deplate::Command::LIST
     end
 end
 
-
-# vim: ff=unix