deplate 0.7.3 → 0.8

data/lib/deplate/elements.rb

@@ -3,14 +3,15 @@
 # @Website:     http://deplate.sf.net/
 # @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
 # @Created:     26-M�r-2004.
-# @Last Change: 02-Nov-2005.
-# @Revision:    0.3718
+# @Last Change: 07-Jun-2006.
+# @Revision:    0.4285
 
+require "deplate/abstract-class"
 
 class Deplate::DontFormatException < Exception
 end
 
-Deplate::CaptionDef = Struct.new('DeplateCaptionDef', :elt, :args)
+Deplate::CaptionDef = Struct.new('DeplateCaptionDef', :elt, :args, :source)
 
 # Deplate::Elements are text entities at line or paragraph level.
 class Deplate::Element < Deplate::BaseElement
@@ -18,15 +19,16 @@ class Deplate::Element < Deplate::BaseElement
 
     @@accumulate_pre  = {}
     @@accumulate_post = {}
-    
+ 
     #### attached labels
     attr_accessor :label
     #### an attached caption (for Table etc.)
-    attr_accessor :caption, :captionOptions
+    attr_reader   :caption
+    attr_accessor :captionOptions
     #### is this element in one-line format?
     attr_accessor :multiliner
     #### end pattern
-    attr_reader :endRx
+    attr_reader   :endRx
     #### the element's level of indentation or whatever
     attr_accessor :level_heading, :top_heading_idx
     #### an array of deferred formatting blocks
@@ -37,22 +39,19 @@ class Deplate::Element < Deplate::BaseElement
     attr_accessor :registered_metadata
     
     attr_reader :line_cont
+    attr_reader :embedable
 
     # class methods & variables
     class << self
-        # the regular expression for this class
-        attr_reader :rx
-        attr_reader :labelling
-
         def match(text)
-            return @rx.match(text)
+            return self.rx.match(text)
         end
 
         def elements
             return @@elements
         end
 
-        def is_volatile?(match)
+        def is_volatile?(match, input)
             false
         end
      
@@ -60,14 +59,6 @@ class Deplate::Element < Deplate::BaseElement
             @@elements << c
         end
 
-        def set_labelling(val=true)
-            @labelling = val
-        end
- 
-        def set_name(name)
-            @name=name
-        end
-        
         def accumulate(src, array, deplate, text, match, *args)
             Deplate::Core.log(["New element", self.name, text], :debug)
             e = self.new(deplate, src, text, match, *args)
@@ -90,10 +81,21 @@ class Deplate::Element < Deplate::BaseElement
             @@accumulate_post[klass] = hooks
         end
 
-        def do_accumulate(src, array, deplate, *args)
-            run_accumulation_hooks(@@accumulate_pre[self], src, array, deplate, *args)
-            accumulate(src, array, deplate, *args)
-            run_accumulation_hooks(@@accumulate_post[self], src, array, deplate, *args)
+        def do_accumulate(src, array, deplate, text, *args)
+            run_accumulation_hooks(@@accumulate_pre[self], src, array, deplate, text, *args)
+            top = array.last
+            accumulate(src, array, deplate, text, *args)
+            indentation  = text.gsub(/^(\s*).*$/, '\\1')
+            shiftwidth   = deplate.variables['tabWidth']
+            shiftwidth   = shiftwidth ? shiftwidth.to_i : 4
+            indent_level = indentation.size / shiftwidth
+            i = -1
+            while ((e = array[i]) and (!top or e != top))
+                e.indentation       = indentation
+                e.indentation_level = indent_level
+                i -= 1
+            end
+            run_accumulation_hooks(@@accumulate_post[self], src, array, deplate, text, *args)
         end
 
         def run_accumulation_hooks(all_hooks, src, array, deplate, *args)
@@ -113,18 +115,20 @@ class Deplate::Element < Deplate::BaseElement
         
         def get_date(arg, args)
             case arg
-            when "now"
+            when 'now', '', nil
                 return Time.new.asctime
-            when "time"
-                return Time.new.strftime("%X")
-            when "today"
-                return Time.new.strftime("%d. %b %Y")
-            when "month"
-                return Time.new.strftime("%B %Y")
-            when "year"
-                return Time.new.strftime("%Y")
-            when "", nil
-                return ""
+            when 'time'
+                return Time.new.strftime('%X')
+            when 'today'
+                return Time.new.strftime('%d. %b %Y')
+            when 'month'
+                return Time.new.strftime('%B %Y')
+            when 'year'
+                return Time.new.strftime('%Y')
+            when 'none', 'nil'
+                return ''
+            # when '', nil
+            #     return ''
             else
                 return Time.new.strftime(arg)
             end
@@ -133,19 +137,24 @@ class Deplate::Element < Deplate::BaseElement
 
     def initialize(deplate, src, text, match, *args)
         super(deplate)
+        @multiliner  = false
         @source      = src
         @text        = text
         @match       = match
         @endRx       = nil
         @fmx         = nil
         @label       = []
-        @collapse    = nil
+        @collapse    = false
         @caption     = nil
         @container   = nil
         @line_cont   = true
+        @embedable   = true
         @postponed_format    = []
         @postponed_preformat = []
         @registered_metadata = []
+        
+        @level = get_level if respond_to?(:get_level)
+        @accum = respond_to?(:get_text) ? [get_text] : []
 
         set_instance_top
 
@@ -177,9 +186,9 @@ class Deplate::Element < Deplate::BaseElement
         if lab
             for l in lab.compact
                 # or @deplate.label_aliases.include?(l)
-                unless @label.include?(l)
+                if anyway or !@label.include?(l)
                     @label << l
-                    @deplate.add_label(self, l, @level_as_string, :anyway => anyway)
+                    @deplate.add_label(self, l, level_as_string, :anyway => anyway)
                 end
             end
         end
@@ -210,8 +219,10 @@ class Deplate::Element < Deplate::BaseElement
         @accum << line
     end
 
-    def to_be_continued?(line)
-        return @multiliner
+    def_abstract :push_match
+
+    def to_be_continued?(line, klass, match)
+        klass.nil? && @multiliner
     end
     
     # compile the accumulated lines in @accum & put the result into @elt
@@ -229,33 +240,42 @@ class Deplate::Element < Deplate::BaseElement
         if @deplate.options.keep_whitespace
             return accum.join("\n")
         else
-            return accum.join(" ")
+            return accum.collect {|l| l.strip}.join(' ')
         end
     end
 
     def process
         process_etc
         process_particles do |e|
-            if e.kind_of?(String)
-                ### <+TBD+> This actually is more of an error and shouldn't be
-                e
-            else
-                rv = e.collect do |p|
+            printable_particles(e)
+        end
+        return self
+    end
+
+    def printable_particles(e)
+        if e.kind_of?(String)
+            ### <+TBD+> This actually is more of an error and shouldn't be
+            e
+        else
+            rv = e.collect do |p|
+                case p
+                when Array
+                    printable_particles(p)
+                else
                     # <+TBD+> begin
                     # p.container = self
                     p.process
                     # rescue Exception => e
-                        # puts e.backtrace.join("\n")
-                        # raise
+                    # puts e.backtrace.join("\n")
+                    # raise
                     # end
                     p.elt
                 end
-                @deplate.join_particles(rv)
             end
+            @deplate.join_particles(rv)
         end
-        return self
     end
-
+    
     def print
         unless @args['swallow']
             for block in @postponed_preformat
@@ -271,7 +291,18 @@ class Deplate::Element < Deplate::BaseElement
     def format_current(formatting_method=nil)
         formatting_method ||= self.class.formatter
         if formatting_method
-            elt = format_element(formatting_method, self)
+            case formatting_method
+            when Array
+                for fm in formatting_method
+                    @elt = format_element(fm, self)
+                end
+                elt = @elt
+            when Symbol
+                elt = format_element(formatting_method, self)
+            else
+                log(['Internal error', 'format_current', self.class.name, formatting_method],
+                    :error)
+            end
         elsif self.respond_to?(:format_special)
             elt = format_special
         else
@@ -308,12 +339,12 @@ class Deplate::Element < Deplate::BaseElement
 
     def label_accum(out, formatting_method)
         fmt = @deplate.formatter
-        if fmt.label_once.include?(formatting_method)
+        if formatting_method and fmt.label_once.include?(formatting_method)
             l = format_element(:format_label, self, :once)
             out.unshift(l) unless l.empty?
         elsif fmt.label_delegate.include?(formatting_method)
         else
-            case label_mode || fmt.label_mode
+            case self.label_mode || fmt.label_mode
             when :once
                 l = format_element(:format_label, self, :once)
                 out.unshift(l) unless l.empty?
@@ -323,7 +354,7 @@ class Deplate::Element < Deplate::BaseElement
             when :after
                 l = format_element(:format_label, self, :after)
                 out.push(l) unless l.empty?
-            when :delegate, :self
+            when :delegate, :self, :none
             else
                 lb = format_element(:format_label, self, :before)
                 la = format_element(:format_label, self, :after)
@@ -350,18 +381,63 @@ class Deplate::Element < Deplate::BaseElement
     end
   
     def register_caption
-        log(["Can't attach caption to", self.class.name], :error)
+        # log(["Can't attach caption to", self.class.name], :error)
+    end
+
+    def set_caption(captiondef, quiet=false)
+        if @caption
+            log('Element already has a caption', :error) unless quiet
+        else
+            self.level_as_string = @deplate.get_current_heading
+            captiondef.elt   = @deplate.parse_with_source(captiondef.source, 
+                                                          captiondef.elt, 
+                                                          false)
+            @caption = captiondef
+            if respond_to?(:register_caption)
+                register_caption
+            end
+        end
     end
 
     def to_plain_text
         @accum.join("\n")
     end
+
+    def element_caption
+        @caption ? @caption.elt : elt_as_caption
+    end
     
+    def elt_as_caption
+        @elt
+    end
+
+    def register_in_listing(list, args={})
+        @deplate.options.listings.push(list, self)
+        
+        en = @deplate.options.listings.get_prop(list, 'entity') || list
+        # nn = @deplate.get_numbering_mode(en, 2)
+        # nn = nil if nn == 0
+        cn = @deplate.options.listings.get_prop(list, 'counter') || list
+        # self.level_as_string = @deplate.options.counters.increase(cn, :to_s => true, :level => nn)
+        self.level_as_string = @deplate.options.counters.increase(cn, :to_s => true)
+        prefix = @deplate.options.listings.get_prop(list, 'prefix') || list
+        label  = @deplate.elt_label(prefix, level_as_string)
+        @label << label
+        @args[:id] ||= label
+
+        @registered_metadata << @deplate.get_metadata(@source,
+                                                      'type' => list,
+                                                      'name' => element_caption,
+                                                      'id'   => get_id
+                                                     )
+    end
+
     protected
     def process_etc
-        if !@caption and @args["caption"]
-            caption  = @deplate.parse(self, @args["caption"])
-            @caption = Deplate::CaptionDef.new(caption, @args)
+        if !@caption and @args['caption']
+            log(['DEBUG: Too late: Add caption', @args['caption']], :error)
+            caption = @deplate.parse(self, @args['caption'])
+            set_caption(Deplate::CaptionDef.new(caption, @args, @source))
         end
         if defined?(@caption) && @caption
             elt = @caption.elt.collect {|p| p.process; p.elt}
@@ -376,19 +452,32 @@ class Deplate::Element < Deplate::BaseElement
     end
 
     def unify_props(other)
-        put_label(other.label, true)
+        if !level_as_string and other.level_as_string
+            self.level_as_string = other.level_as_string
+        end
+        l = [other.args['id'], other.args[:id], *other.label]
+        l.compact!
+        l.uniq!
+        put_label(l, true)
         @args.update(other.args)
+        # p "DBG", self.class, other.class, @args.keys, other.args.keys
         @level          ||= other.level
-        @caption        ||= other.caption
-        @captionOptions ||= other.captionOptions
         @source.begin   ||= other.source.begin
         @source.end       = other.source.end if other.source.end
+        @indentation    ||= other.indentation
+        @indentation_level ||= other.indentation_level
+        @captionOptions ||= other.captionOptions
+        if !@caption
+            cap = @args['caption']
+            if cap
+                set_caption(Deplate::CaptionDef.new(cap, @args, @source))
+            elsif other.caption
+                @caption = other.caption
+            end
+        end
         if other.styles
             update_styles(other.styles)
         end
-        if !level_as_string and other.level_as_string
-            self.level_as_string = other.level_as_string
-        end
     end
     
     def unify_elt(other)
@@ -401,7 +490,8 @@ class Deplate::Element < Deplate::BaseElement
 
     def container=(element)
         @container = element
-        @args      = element.args
+        # @args      = element.args
+        @args.update(element.args)
         @postponed_format    = element.postponed_format
         @postponed_preformat = element.postponed_preformat
     end
@@ -433,86 +523,305 @@ class Deplate::Element < Deplate::BaseElement
         if @elt
             @elt = (@elt.collect(&block)).join
         else
-            log(["Internal error: no @elt", self.class], :error)
+            log(["Internal error: No @elt", self.class], :error)
             @elt = ""
         end
     end
     alias process_elements process_particles
 
     def register_figure
-        @deplate.table_of_figures << self
-        @deplate.current_figure += 1
-        @level_as_string = [@deplate.current_heading[0], @deplate.current_figure].join(".")
-        @label << @deplate.elt_label("fig", @level_as_string)
+        register_in_listing('lof')
     end
     
     def register_table
-        @deplate.table_of_tables << self
-        @deplate.current_table += 1
-        @level_as_string = [@deplate.current_heading[0], @deplate.current_table].join(".")
-        @label << @deplate.elt_label("tab", @level_as_string)
+        register_in_listing('lot')
     end
 end
 
+
 class Deplate::Element::Comment < Deplate::Element
     register_element
-    set_rx(/^\s*(%+)[ \t]*(.*)$/)
-
+    set_rx(/^\s*(%+)[[:blank:]]*(.*)$/)
+    def_get :level, lambda {@match[1].size}
+    def_get :text, 2
+    
     # disappear
     def self.accumulate(src, array, deplate, text, match)
         Deplate::Core.log(["Hide comment", text], :debug)
     end
 
     def setup
-        @multiliner = false
+        @collapse = true
+    end
+end
+
+
+class Deplate::Element::Note < Deplate::Element
+    register_element
+    set_formatter :format_note
+    set_rx(/^([[:blank:]]+)([#!?+]{3,3})\s+(.*)$/)
+    def_get :level, lambda {expand_tab(@match[1]).size}
+    def_get :marker, lambda {@match[2][0..0]}
+    def_get :text, 3
+
+    attr_reader :marker
+
+    def setup
+        @multiliner = true
+        @marker     = get_marker
+    end
+    
+    def to_be_continued?(line, klass, match)
+        indent = get_indent(line).size
+        return indent >= @level
+    end
+end
+
+
+Deplate::ListItem   = Struct.new('DeplateListItem', :item, :body, :listtype, :type,
+                                 :level, :max, :explicit, :label, :style, :opts,
+                                 :preformatted)
+
+class Deplate::List < Deplate::Element
+    set_formatter :format_list
+    class_attribute :listtype
+    # class_attribute :not_embedable, []
+
+    def_get :opts
+    def_get :level, lambda {expand_tab(@match[2]).size}
+    def_get :level_max, lambda {expand_tab(@match[1]).size}
+    def_get :item, 3
+    def_get :text, 4
+
+    attr_reader :levelRange, :item, :oitem
+   
+    def setup
+        @multiliner = true
         @collapse   = true
-        @level      = get_level
-        @accum      = [get_text]
+        @itemopts   = get_opts
+        if self.instance_of?(Deplate::List::Description)
+            @levelMax = @level + (@deplate.variables["tabwidth"] || 4)
+        else
+            @levelMax = get_level_max
+        end
+        @oitem = @item = get_item
     end
 
-    def get_level
-        @match[1].size
+    def collapsable?(other)
+        if other.kind_of?(Deplate::List)
+            return true
+        elsif other.kind_of?(Deplate::Element::Paragraph)
+            return @elt.find do |i|
+                continuation_level_ok?(other.level, i.level, i.max)
+            end
+        elsif other.kind_of?(Deplate::Element::Whitespace)
+            return true
+        elsif indentation_level_ok?(other) and other.embedable
+            # and !self.class.not_embedable.include?(other.class)
+            return true
+        else
+            return false
+        end
+    end
+
+    def unify_now(other)
+        if other.kind_of?(Deplate::Element::Paragraph)
+            @elt << Deplate::ListItem.new([], other.elt.flatten, @elt.last.listtype, 
+                                        "Paragraph", other.level, other.level, 
+                                         other.is_explicit?, other.label,
+                                         other.class.name)
+            other.label = []
+            unify_props(other)
+        elsif other.kind_of?(Deplate::Element::Whitespace)
+        elsif other.kind_of?(Deplate::List)
+            super
+        else
+            e = @elt.last
+            unless e.type == 'Container' and e.body.unify(other)
+                # unify_props(other)
+                l = other.level
+                unless l
+                    l   = e.level if e
+                    l ||= level
+                end
+                @elt << Deplate::ListItem.new([], other, @elt.last.listtype, 
+                                              "Container", l, l, 
+                                              other.is_explicit?, other.label,
+                                              other.class.name)
+            end
+        end
     end
 
-    def get_text
-        @match[2]
+    def to_be_continued?(line, klass, match)
+        linelevel = get_indent(line).size
+        klass.nil? && continuation_level_ok?(linelevel, @level, @levelMax)
+    end
+
+    def continuation_level_ok?(otherLevel, thisLevel, thisMaxLevel)
+        # return thisLevel <= otherLevel && otherLevel <= thisMaxLevel
+        return thisLevel <= otherLevel
+    end
+    
+    def indentation_level_ok?(other)
+        return indentation <= other.indentation
+    end
+    
+    def finish
+        finish_item
+        finish_elt
+        @label = []
+        return self
+    end
+
+    def finish_item
+        @item  = @deplate.parse(self, @item)
+    end
+
+    def finish_elt
+        accum  = @deplate.parse(self, @accum.join(" "))
+        type   = self.class.listtype
+        @elt   = [Deplate::ListItem.new(@item, accum, type, type, @level, 
+                                        @levelMax, is_explicit?, @label,
+                                        type, @itemopts)]
+    end
+    
+    def process_particles(&block)
+        @elt.each do |e|
+            e.item = block.call(e.item)
+            case e.type
+            when 'Container'
+                # <+TBD+> This doesn't work for all elements (e.g. 
+                # volatile elements)
+                # e.body.process_particles(&block)
+                e.body = e.body.process
+            else
+                e.body = block.call(e.body)
+            end
+        end
+    end
+end
+
+
+class Deplate::List::Ordered < Deplate::List
+    register_element
+    set_rx(/^(([[:blank:]]+)([0-9]+\.|[#\@?]\.?|[a-zA-Z?]\.)[[:blank:]]+)(.+)$/)
+    self.listtype = "Ordered"
+    
+    def is_explicit?
+        if @oitem =~ /^[0-9a-zA-Z]+\.$/
+            return true
+        else
+            return false
+        end
+    end
+end
+
+
+class Deplate::List::Itemize < Deplate::List
+    register_element
+    set_rx(/^(([[:blank:]]+)([-�+*])[[:blank:]]+)(.+)$/)
+    self.listtype = "Itemize"
+end
+
+
+class Deplate::List::Description < Deplate::List
+    register_element
+    set_rx(/^(([[:blank:]]+)(.+?)[[:blank:]]+::[[:blank:]])(.*)$/)
+    self.listtype = "Description"
+end
+
+
+class Deplate::List::Task < Deplate::List
+    register_element
+    set_rx(/^(([[:blank:]]+)#(([0-9][A-Z]?|[A-Z][0-9]?)[[:blank:]]+(_|x|x?[0-9-]+%?)|(_|x|x?[0-9-]+%?)[[:blank:]]+([0-9][A-Z]?|[A-Z][0-9]?)))[[:blank:]]+(.*)$/)
+    self.listtype = 'Task'
+    def_get :item, lambda {[@itemopts[:priority], @itemopts[:category]].join}
+    def_get :text, 8
+    
+    attr_accessor :task
+
+    def finish_item
+        # @item = @deplate.parse(self, @item)
+    end
+
+    def get_opts
+        if defined?(@task) and @task
+            return @task
+        end
+
+        item = @match[3]
+        rv   = {}
+        type, due = item.split(/\s+/)
+        if type =~ /^(_|x|x?[\d-]+%?)$/
+            type, due = due, type
+        end
+        
+        if type =~ /^([0-9])([A-Z]?)$/
+            rv[:priority] = $1
+            rv[:category] = $2 unless $2.empty?
+        elsif type =~ /^([A-Z])([0-9]?)$/
+            rv[:priority] = $2
+            rv[:category] = $1 unless $1.empty?
+        else
+            log(['Invalid task item', item], :error)
+        end
+
+        if due =~ /^\s*x/
+            rv[:done] = true
+        end
+        if due =~ /^\s*x?([0-9-]+%?)/
+            # rv[:due] = ParseDate::parsedate($1, true)
+            rv[:due] = $1
+        end
+
+        rv
     end
 end
 
+
 class Deplate::Element::Region < Deplate::Element
     register_element
     set_rx(/^(\s*)#([A-Z]([a-z][A-Za-z]*)?)\b(.*)(\<\<(.+)|:)\s*$/)
-    @rxi_name   = 2
-    @rxi_args   = 4
-    @rxi_endrx  = 6
-    @rxi_indent = 1
 
-    attr_reader :specified, :regNote, :name
+    class_attribute :rxi_indent, 1
+    class_attribute :rxi_name,   2
+    class_attribute :rxi_args,   4
+    class_attribute :rxi_endrx,  6
 
-    class << self
-        attr_reader :rxi_name, :rxi_args, :rxi_endrx, :rxi_indent
+    def_get :name,   lambda {@match[self.class.rxi_name]}
+    def_get :args,   lambda {@match[self.class.rxi_args]}
+    def_get :indent, lambda {@match[self.class.rxi_indent]}
+    def_get :endrx,  lambda {
+        i = self.class.rxi_endrx
+        if @match[i - 1] == ":"
+            /^(#{get_indent})?#End\s*$/
+        else
+            erx = @match[i]
+            if erx
+                /^(#{get_indent})?#{Regexp.escape(erx)}\s*$/
+            end
+        end
+    }
 
+    class << self
         def pseudo_match(args)
-            [
-                nil,
-                args[:indent],  #1
-                args[:name],    #2
-                nil,            #3
-                args[:args],    #4
-                nil,            #5
-                args[:endrx],   #6
-            ]
+            rv = []
+            rv[rxi_indent] = args[:indent]
+            rv[rxi_args]   = args[:args]
+            rv[rxi_name]   = args[:name]
+            rv[rxi_endrx]  = args[:endrx]
+            rv
         end
     end
+
+    attr_reader :specified, :regNote, :name
     
     def setup(name=nil)
         @multiliner = true
         @endRx      = get_endrx
-        @accum      = []
         @name       = name || get_name
         begin
             @args, @regNote = @deplate.input.parse_args(get_args)
-            @collapse       = false
             region = @deplate.input.regions[@name]
             unless region
                 if @deplate.formatter.matches?(@name)
@@ -529,96 +838,37 @@ class Deplate::Element::Region < Deplate::Element
             region = Deplate::Regions::UNKNOWN
         end
         @specified = region.new(@deplate, @source, @text, @match, self)
-        @specified.indent = get_indent
         @line_cont = region.line_cont
         # @deplate.register_id(@args, @specified)
         @deplate.register_id(@args, self)
     end
 
-    def get_name
-        @match[self.class.rxi_name]
-    end
-
-    def get_args
-        @match[self.class.rxi_args]
-    end
-    
-    def get_endrx
-        i = self.class.rxi_endrx
-        if @match[i - 1] == ":"
-            /^(#{get_indent})?#End\s*$/
-        else
-            erx = @match[i]
-            if erx
-                /^(#{get_indent})?#{Regexp.escape(erx)}\s*$/
-            end
-        end
-    end
-
-    def get_indent
-        @match[self.class.rxi_indent]
-    end
-    
     def finish
+        update_region
         return @specified.finish
     end
-end
 
-class Deplate::Element::Clip < Deplate::BaseElement
-    attr_reader :is_template
-    # attr_accessor :prototype
-
-    def initialize(acc, deplate, source)
-        super(deplate)
-        @acc         = acc
-        @elt         = nil
-        @source      = source
-        @invoker     = nil
-        @is_template = false
-        @prototype   = nil
+    def finished?
+        @specified.finished?
     end
 
-    def process
-        unless @prototype
-            @prototype = @acc.first
-            @prototype.args.update(@args) if @prototype
-        end
-        unless @elt
-            @elt = @acc.collect{|p| p.process; p.elt}
-            @elt = @deplate.join_particles(@elt)
-        end
-        return self
-    end
-   
-    def format_clip(invoker, expected)
-        unless @elt
-            log("We shouldn't be here. If you can track down when this happens, please send an example to the author.", :anyway)
-            process
-        end
-        if @elt
-            @prototype.match_expected(expected, invoker)
-        else
-            log("Clip is nil, which is quite strange and most likely deplate's error but as I haven't had the time yet to track this down this error still occurs.", :error)
-        end
-        @elt
-    end
-    
-    def print
-        output(@elt)
+    def update_region
+        @specified.indentation = indentation
+        @specified.indent      = get_indent
     end
 end
 
+
 class Deplate::Element::Command < Deplate::Element
     register_element
-    set_rx /^\s*#([A-Z]+)((\s[^:]+)?(:\s*(.+?)\s*)?)$/
+    set_rx(/^\s*#([A-Z]+)((\s[^:]+)?(:\s*(.+?)\s*)?)$/)
     attr :name
    
     class << self
-        def is_volatile?(match)
-            case match[1]
-            when "IDX", "NOIDX", "DONTIDX", "AUTOIDX", "DOC", "OPT", "AUTHOR", 
-                "TITLE", "DATE", "ABBREV"
-                true
+        def is_volatile?(match, input)
+            cmd = input.commands[match[1]]
+            if cmd
+                cmd.volatile
             else
                 false
             end
@@ -626,15 +876,15 @@ class Deplate::Element::Command < Deplate::Element
         
         def accumulate(src, array, deplate, text, match)
             cmd = match[1]
-            Deplate::Core.log(["Command", cmd, text], :debug)
+            Deplate::Core.log(['Command', cmd, text], :debug)
             begin
                 args, text = deplate.input.parse_args(match[2])
                 case cmd
-                when "IF"
+                when 'IF'
                     deplate.switches << !check_switch(deplate, text)
-                when "ELSEIF"
+                when 'ELSEIF'
                     if deplate.switches.empty?
-                        Deplate::Core.log(["ELSEIF without IF", cmd, match[0]], :error, src)
+                        Deplate::Core.log(['ELSEIF without IF', cmd, match[0]], :error, src)
                     else
                         case deplate.switches.last
                         when :skip
@@ -646,9 +896,9 @@ class Deplate::Element::Command < Deplate::Element
                             deplate.switches << :skip
                         end
                     end
-                when "ELSE"
+                when 'ELSE'
                     if deplate.switches.empty?
-                        Deplate::Core.log(["ELSE without IF", cmd, match[0]], :error, src)
+                        Deplate::Core.log(['ELSE without IF', cmd, match[0]], :error, src)
                     else
                         case deplate.switches.last
                         when :skip
@@ -659,9 +909,9 @@ class Deplate::Element::Command < Deplate::Element
                             deplate.switches << :skip
                         end
                     end
-                when "ENDIF"
+                when 'ENDIF'
                     if deplate.switches.empty?
-                        Deplate::Core.log(["ENDIF without IF", cmd, match[0]], :error, src)
+                        Deplate::Core.log(['ENDIF without IF', cmd, match[0]], :error, src)
                     else
                         deplate.switches.pop
                     end
@@ -671,12 +921,12 @@ class Deplate::Element::Command < Deplate::Element
                         if cc
                             cc.do_accumulate(src, array, deplate, text, match, args, cmd)
                         else
-                            Deplate::Core.log(["Unknown command", cmd, match[0]], :error, src)
+                            Deplate::Core.log(['Unknown command', cmd, match[0]], :error, src)
                         end
                     end
                 end
             rescue Deplate::DontFormatException
-                Deplate::Core.log(["Dropping", match[0]], nil, src)
+                Deplate::Core.log(['Dropping', match[0]], nil, src)
             end
         end
 
@@ -694,24 +944,38 @@ class Deplate::Element::Command < Deplate::Element
                 end
                 val = m[4]
                 op  = val ? m[3] : m[2]
-                if op == "!"
-                    return get_var_or_option(deplate, var)
+                case val
+                when 'true'
+                    val = true
+                when 'false'
+                    val = false
+                when nil
+                else
+                    val = Deplate::Core.remove_backslashes(val.strip)
+                end
+                if op == '!'
+                    switch = get_var_or_option(deplate, var)
+                    if negate
+                        return !switch
+                    else
+                        return switch
+                    end
                 else
                     case op
-                    when "==", "!="
+                    when '==', '!='
                         compare = Proc.new {|a, b| a == b}
-                    when "=~", "!=~"
+                    when '=~', '!=~'
                         compare = Proc.new {|a, b| a =~ Regexp.new(b)}
                     else
-                        raise "Internal error"
+                        raise 'Internal error'
                     end
                     case var
-                    when "fmt"
+                    when 'fmt'
                         switch = compare.call(deplate.formatter.formatter_name, val)
                     else
                         switch = compare.call(get_var_or_option(deplate, var), val)
                     end
-                    if op[0..0] == "!" or negate
+                    if op[0..0] == '!' or negate
                         return !switch
                     else
                         return switch
@@ -720,7 +984,7 @@ class Deplate::Element::Command < Deplate::Element
             elsif text =~ /^\w+$/
                 return get_var_or_option(deplate, text)
             else
-                Deplate::Core.log(["Malformed condition", text], :error)
+                Deplate::Core.log(['Malformed condition', text], :error)
                 return true
             end
         end
@@ -731,181 +995,21 @@ class Deplate::Element::Command < Deplate::Element
             elsif deplate.options.allow.include?(':') && key =~ /^:(.*)$/
                 return deplate.options.send($1)
             end
-            Deplate::Core.log(["Unknown variable or option", key])
+            Deplate::Core.log(['Unknown variable or option', key])
             return nil
         end
     end
 end
 
-class Deplate::Element::Note < Deplate::Element
-    register_element
-    set_formatter :format_note
-    set_rx /^([ \t]+)([#!?+]{3,3})\s+(.*)$/
-
-    attr_reader :marker
-
-    def setup
-        @multiliner   = true
-        @collapse     = false
-        @level        = get_level
-        @marker       = get_marker
-        @accum        = [get_text]
-    end
-    
-    def to_be_continued?(line)
-        indent = get_indent(line).size
-        return indent >= @level
-    end
-
-    def get_level
-        expand_tab(@match[1]).size
-    end
-
-    def get_marker
-        @match[2][0..0]
-    end
-
-    def get_text
-        @match[3]
-    end
-end
-
-Deplate::ListItem   = Struct.new("DeplateListItem", :item, :body, :listtype, :type,
-                                 :level, :max, :explicit, :label, :style)
-
-class Deplate::List < Deplate::Element
-    set_formatter :format_list
-    set_labelling
-    
-    attr_reader :levelRange, :item, :oitem
-    
-    class << self
-        attr :name
-    end
-    
-    def setup
-        @multiliner = true
-        @collapse   = true
-        @level      = get_level
-        if self.instance_of?(Deplate::List::Description)
-            @levelMax = @level + (@deplate.variables["tabwidth"] || 4)
-        else
-            @levelMax = get_level_max
-        end
-        @oitem = @item = get_item
-        @accum = [get_text]
-    end
-
-    def get_level
-        expand_tab(@match[2]).size
-    end
-
-    def get_level_max
-        expand_tab(@match[1]).size
-    end
-
-    def get_item
-        @match[3]
-    end
-
-    def get_text
-        @match[4]
-    end
-
-    def collapsable?(other)
-        if other.kind_of?(Deplate::List)
-            return true
-        elsif other.kind_of?(Deplate::Element::Paragraph)
-            return @elt.find do |i|
-                continuation_level_ok?(other.level, i.level, i.max)
-            end
-        elsif other.kind_of?(Deplate::Element::Whitespace)
-            return true
-        else
-            return false
-        end
-    end
-
-    def unify_now(other)
-        if other.kind_of?(Deplate::Element::Paragraph)
-            @elt << Deplate::ListItem.new([], other.elt.flatten, @elt.last.listtype, 
-                                        "Paragraph", other.level, other.level, 
-                                         other.is_explicit?, other.label)
-            other.label = []
-            unify_props(other)
-        elsif other.kind_of?(Deplate::Element::Whitespace)
-        else
-            super
-        end
-    end
-
-    def to_be_continued?(line)
-        linelevel = get_indent(line).size
-        return continuation_level_ok?(linelevel, @level, @levelMax)
-    end
-
-    def continuation_level_ok?(otherLevel, thisLevel, thisMaxLevel)
-        # return thisLevel <= otherLevel && otherLevel <= thisMaxLevel
-        return thisLevel <= otherLevel
-    end
-    
-    def finish
-        @item  = @deplate.parse(self, @item)
-        accum  = @deplate.parse(self, @accum.join(" "))
-        name   = self.class.name
-        @elt   = [Deplate::ListItem.new(@item, accum, name, name, @level, 
-                                        @levelMax, is_explicit?, @label)]
-        @label = []
-        return self
-    end
-
-    def process_particles(&block)
-        @elt.each do |e|
-            e.item = block.call(e.item)
-            e.body = block.call(e.body)
-        end
-    end
-end
-
-class Deplate::List::Numbered < Deplate::List
-    register_element
-    set_formatter :format_list
-    set_rx /^(([ \t]+)([0-9]+\.|[#\@?]\.?|[a-zA-Z?]\.)[ \t]+)(.+)$/
-    set_name "Numbered"
-    
-    def is_explicit?
-        if @oitem =~ /^[0-9a-zA-Z]+\.$/
-            return true
-        else
-            return false
-        end
-    end
-end
-
-class Deplate::List::Itemize < Deplate::List
-    register_element
-    set_formatter :format_list
-    set_rx /^(([ \t]+)([-�+*])[ \t]+)(.+)$/
-    set_name "Itemize"
-end
-
-class Deplate::List::Description < Deplate::List
-    register_element
-    set_formatter :format_list
-    set_rx /^(([ \t]+)(.+?)[ \t]+::[ \t])(.*)$/
-    set_name "Description"
-end
-
-
 
 class Deplate::Element::Table < Deplate::Element
     register_element
     set_formatter :format_table
-    set_rx /^(\|\|?)([ \t]+.+[ \t]+)\1$/
+    set_rx(/^\s*(\|\|?)([[:blank:]]+.+[[:blank:]]+)\1\s*$/)
 
-    TableRow  = Struct.new("DeplateTableRow", :high, :cols, :head, :foot, :is_ruler,
+    TableRow  = Struct.new('DeplateTableRow', :high, :cols, :head, :foot, :is_ruler,
                            :from_top, :from_bottom)
-    TableCell = Struct.new("DeplateTableCell", :cell, 
+    TableCell = Struct.new('DeplateTableCell', :cell, 
                            :x, :y, :from_right, :from_bottom,
                            :high, :head, :foot,
                            :span_x, :span_y, :row)
@@ -914,7 +1018,7 @@ class Deplate::Element::Table < Deplate::Element
         :contains_footnotes, :printed_header
 
     def setup
-        @multiliner  = false
+        @multiliner  = :match
         @collapse    = true
         high         = get_highlight
         cols         = get_cols
@@ -925,12 +1029,23 @@ class Deplate::Element::Table < Deplate::Element
         @contains_footnotes = false
     end
 
-    def get_highlight
-        @match[1].size == 2
+    def to_be_continued?(line, klass, match)
+        klass == self.class
+    end
+
+    def push_match(match)
+        high         = get_highlight(match)
+        cols         = get_cols(match)
+        cols.collect! {|t| t.strip}
+        @accum << TableRow.new(high, cols)
+    end
+
+    def get_highlight(match=@match)
+        match[1].size == 2
     end
 
-    def get_cols
-        @match[2].split(/[ \t]\|\|?[ \t]/)
+    def get_cols(match=@match)
+        match[2].split(/[[:blank:]]\|\|?[[:blank:]]/)
     end
     
     def unify_now(other)
@@ -1078,18 +1193,25 @@ class Deplate::Element::Table < Deplate::Element
         end
     end
 
+    def unify_props(other)
+        super
+    end
+    
     def register_caption
         register_table
     end
 end
 
+
 class Deplate::Element::Heading < Deplate::Element
     attr_accessor :first_top, :last_top, :top_index, :abstract
     attr_writer :destination
     
     register_element
     set_formatter :format_heading
-    set_rx /^(\*+)[ \t]+(.*?)$/
+    set_rx(/^(\*+)[[:blank:]]+(.*?)$/)
+    def_get :level, lambda {@match[1].size}
+    def_get :text, 2
 
     class << self
         def accumulate(src, array, deplate, text, match)
@@ -1109,15 +1231,10 @@ class Deplate::Element::Heading < Deplate::Element
     end
     
     def set_instance_top
-        @level = get_level
         ls = @deplate.variables["levelshift"]
         if ls
              @level += ls.to_i
         end
-        if is_top_heading?
-            @deplate.current_table  = 0
-            @deplate.current_figure = 0
-        end
         @deplate.increase_current_heading(@level)
         super
     end
@@ -1125,28 +1242,18 @@ class Deplate::Element::Heading < Deplate::Element
     def setup
         @first_top   = false
         @last_top    = false
-        @multiliner  = false
-        @collapse    = false
         @abstract    = nil
-        @accum       = [get_text]
-        @args[:id]   = @deplate.elt_label("hd", @level_as_string)
         @destination = @deplate.output.destination
         @top_index   = [0, 0]
-        @deplate.table_of_contents << self
+        @args[:id]   = @deplate.elt_label('hd', level_as_string)
+        @deplate.options.listings.push('toc', self)
+        # register_in_listing('toc')
         @deplate.headings[@level_heading] = self
         update_args
     end
 
-    def get_level
-        @match[1].size
-    end
-
-    def get_text
-        @match[2]
-    end
-
     def is_top_heading?
-        @level == 1
+        @level <= @deplate.options.split_level
     end
     
     def update_options(args)
@@ -1166,7 +1273,24 @@ class Deplate::Element::Heading < Deplate::Element
     end
     
     def process
-        rv = super
+        rv  = super
+        url = @args['url']
+        hh  = @deplate.variables['hyperHeading']
+        if url and hh
+            if hh == 'full'
+                # <+TBD+> Extract invalid tags and move them add them to the 
+                # end of the result (but this has to be done by the 
+                # formatter, so well ...)
+                rv.elt = @deplate.formatter.format_particle(:format_url, rv, rv.elt, url, nil)
+            else
+                button = @deplate.variables['hyperHeadingButton'] ||
+                    @deplate.parse_and_format_without_wikinames(self, 
+                                                                # '{img alt="=>": hyperHeading}', 
+                                                                '=>', 
+                                                                false)
+                rv.elt += @deplate.formatter.format_particle(:format_url, rv, button, url, nil)
+            end
+        end
         if rv.is_top_heading?
             @deplate.options.heading_names[@top_heading_idx] = rv.elt
             if @deplate.variables['subToC']
@@ -1174,7 +1298,7 @@ class Deplate::Element::Heading < Deplate::Element
                 match = []
                 toc = Deplate::Command::LIST.new(@deplate, @source, 'toc', match, args, 'LIST')
                 toc.level = @level
-                toc.level_as_string = @level_as_string
+                toc.level_as_string = level_as_string
                 rv = [rv, toc.finish.process].compact.flatten
             end
         end
@@ -1197,49 +1321,48 @@ class Deplate::Element::Heading < Deplate::Element
     end
     
     def description
-        if @args['shortcaption']
-            @args['shortcaption']
-        elsif @caption
-            @caption.elt
-        else
-            @elt
-        end
+        desc = if @args['shortcaption']
+                   @args['shortcaption']
+               elsif @caption
+                   @caption.elt
+               else
+                   @elt
+               end
+        printable_particles(desc)
     end
 
     def register_caption
-        @deplate.table_of_contents << self
-        @label << @deplate.elt_label('hd', @level_as_string)
+        @deplate.options.listings.push('toc', self)
+        @label << @deplate.elt_label('hd', level_as_string)
     end
 end
 
+
 class Deplate::Element::Break < Deplate::Element
     register_element
     set_formatter :format_break
-    set_rx /^\s*-{2,}8\<-{2,}\s*$/
-
-    def setup
-        @multiliner   = false
-        @collapse     = false
-        @accum        = []
-    end
+    set_rx(/^\s*-{2,}8\<-{2,}\s*$/)
 end
 
+
 # An anchor is not a proper element, but is attached to the preceding one
 class Deplate::Element::Anchor < Deplate::Element
     register_element
     set_formatter :format_anchor
-    set_rx /^\s*%?#([a-z][a-zA-Z0-9:_-]+).*$/
+    set_rx(/^\s*%?#([a-z][a-zA-Z0-9:_-]+)(.*)$/)
 
     class << self
         def accumulate(src, array, deplate, text, match)
             i = 0
             l = get_text(match)
             Deplate::Core.log(['New anchor', l], :debug)
+            r = get_rest(match)
+            if r and !r.empty?
+                Deplate::Core.log(['Deprecated: Text after anchor', r], :error, src)
+            end
             last = array.last
             if last and last.can_be_labelled
                 last.put_label([l])
-                # last.args["label"] ||= l
-                deplate.labels_named << l
             else
                 Deplate::Core.log(["Defer label", l], nil, src)
                 deplate.labels_floating << l
@@ -1250,7 +1373,11 @@ class Deplate::Element::Anchor < Deplate::Element
             match[1]
         end
         
-        def is_volatile?(match)
+        def get_rest(match)
+            match[2]
+        end
+        
+        def is_volatile?(match, input)
             true
         end
     end
@@ -1264,10 +1391,12 @@ class Deplate::Element::Anchor < Deplate::Element
     end
 end
 
+
 # just disappear
 class Deplate::Element::Whitespace < Deplate::Element
     register_element
-    set_rx /^\s*$/
+    set_rx(/^\s*$/)
+    def_get :text, lambda {@text}
 
     class << self
         def accumulate(src, array, deplate, text, match)
@@ -1284,9 +1413,7 @@ class Deplate::Element::Whitespace < Deplate::Element
     end
 
     def setup(kw)
-        @multiliner = false
-        @collapse   = true
-        @accum      = [@text]
+        @collapse = true
         @can_be_labelled = false
         @keep_whitespace = kw
     end
@@ -1308,9 +1435,8 @@ class Deplate::Element::PotentialPageBreak < Deplate::Element
     set_formatter :format_PAGEBREAK
     attr_accessor :enabled
     
-    def initialize(*args)
+    def setup
         @enabled = false
-        super
     end
     
     def process
@@ -1327,29 +1453,70 @@ end
 # matches
 class Deplate::Element::Paragraph < Deplate::Element
     set_formatter :format_paragraph
-    set_rx /^([ \t]*)(.+)[ \t]*$/
+    set_rx(/^([[:blank:]]*)(.+)[[:blank:]]*$/)
+    def_get :level, lambda {get_indent(@match[1]).size}
+    def_get :text, lambda {@deplate.options.keep_whitespace ? @match[0] : @match[2]}
 
     class << self
         def from_text(deplate, src, text)
-            m = @rx.match(text)
+            m = self.rx.match(text)
             self.new(deplate, src, text, m)
         end
     end
     
     def setup
         @multiliner = true
-        @collapse   = false
-        @level      = get_level
-        @accum      = [get_text]
     end
+end
+
 
-    def get_level
-        get_indent(@match[1]).size
+class Deplate::Element::Clip < Deplate::BaseElement
+    attr_reader :is_template
+    # attr_accessor :prototype
+
+    def initialize(acc, deplate, source)
+        super(deplate)
+        @acc         = acc
+        @elt         = nil
+        @source      = source
+        @invoker     = nil
+        @is_template = false
+        @prototype   = nil
     end
 
-    def get_text
-        @deplate.options.keep_whitespace ? @match[0] : @match[2]
+    def process
+        unless @prototype
+            @prototype = @acc.first
+            @prototype.args.update(@args) if @prototype
+        end
+        unless @elt
+            @elt = @acc.collect{|p| p.process; p.elt}
+            @elt = @deplate.join_particles(@elt)
+        end
+        return self
+    end
+   
+    def format_clip(invoker, expected)
+        unless @elt
+            log("We shouldn't be here. If you can track down when this happens, please send an example to the author.", :anyway)
+            process
+        end
+        if @elt
+            if @prototype
+                @prototype.match_expected(expected, invoker)
+            elsif @elt =~ /\S/
+                log(['Internal error', 'prototype=nil', @elt], :error)
+            end
+        else
+            log("Clip is nil, which is quite strange and most likely deplate's error but as I haven't had the time yet to track this down this error still occurs.", :error)
+        end
+        @elt
+    end
+    
+    def print
+        output(@elt)
     end
 end
 
+
 # vim: ff=unix