docgenerator 1.0.4 → 1.1.1

data/lib/wiki2doc/wiki2docgenerator.rb

@@ -28,243 +28,243 @@ end
 #The proc contains three block-parameter: The match-element, the Wikitext-object and the logger-object.
 Wikireg = Struct.new( 'WikiReg', :rule, :regex, :proc )
 class Wikireg	
-	@@give_message = true
-	def self.give_message=(val); @@give_message = val; 	end
-	def self.give_message?(); return @@give_message; 	end
+  @@give_message = true
+  def self.give_message=(val); @@give_message = val; 	end
+  def self.give_message?(); return @@give_message; 	end
 end
 
 #Constant with all Standard-replacemnts of Wikis.
 #Each replacement should also convert the part before and after the match.
 WIKI_INLINE_REPLACEMENTS =	[
-	#[[Bild:Dateiname|Zusatzinfos|Beschreibung]]
-	#Zusatzinfos:
-	#	-left
-	#	-right
-	Wikireg.new(:bild, /\[\[Bild:(.*?)\]\]/,
-								Proc.new{|m, oo, log| 
-									parameter = m[1].split('|')
-									[	oo.inline(m.pre_match, log),
-										oo.wiki_bild( parameter.first, parameter[1..-1], log),
-										oo.inline(m.post_match, log),
-									]
-							} ),
-	Wikireg.new(:file, /\[\[File:(.*)\]\]/,
-								Proc.new{|m, oo, log| 
-									parameter = m[1].split('|')
-									filename = parameter[0]
-									if parameter.size > 1
-										txt = "#{parameter.last}"
-									else
-										txt = File.basename(filename)
-									end
-									if  Wikireg.give_message? and ! File.exist?(filename)
-									  log.warn( "Link to unexisting local file #{filename} (from #{Dir.pwd})" ) if log.warn?
-									end
-									
-									css = CSS.new()
-									parameter[1..-2].each{|p|
-										case p
-											when 'size'
-												txt << " (#{File.size(filename)/1024}KB)"	if File.exist?(filename)
-											when /(.*)=>(.*)/
-												css[$1] = $2
-											else
-												log.warn( "Wiki-File with unknown setting #{p}" ) if log.warn?
-										end
-									}
-									#Result:
-									[ 
-										oo.inline(m.pre_match, log), 
-										element(:a, { :href => filename, :alt => txt, :style => css  }, oo.inline(txt, log) ),
-										oo.inline(m.post_match,log)
-								]} ),
-	Wikireg.new(:label, %r{\[\[label:(.*)\]\]},
-								Proc.new{|m, oo, log| 
-										[	oo.inline(m.pre_match, log), 
-											element(:label, { :name => m[1]} ),
-											oo.inline(m.post_match, log)
-										]
-								} ),
-	Wikireg.new(:ref, %r{<ref>(.*)</ref>},
-								Proc.new{|m, oo, log| 
-								puts "<ref> is obsolete, use {{footnote}}. To get footnotes set {{footnotes|ref}}"
-										[	oo.inline(m.pre_match, log), 
-											element(:footnote, { :groupid =>  'ref' }, oo.inline(m[1],log) ),
-											oo.inline(m.post_match, log)
-										]
-								} ),
-	Wikireg.new(:bf_it, /''''(.*?)''''/,
-								Proc.new{|m, oo, log| [ oo.inline(m.pre_match, log), 
-														element(:textbf, {}, element(:emph, {}, oo.inline(m[1], log) )),
-														oo.inline(m.post_match, log)
-								]} ),
-	Wikireg.new(:bf, /'''(.*?)'''/,
-								Proc.new{|m, oo, log| [ oo.inline(m.pre_match, log), 
-														element(:textbf, {}, oo.inline(m[1], log)),
-														oo.inline(m.post_match, log)
-								]} ),
-	Wikireg.new(:it, /''(.*?)''/,
-								Proc.new{|m, oo, log| [ oo.inline(m.pre_match, log), 
-														element(:emph, {}, oo.inline(m[1], log)),
-														oo.inline(m.post_match, log)
-								]} ),
-	#Soll in Wikipedia-Artikeln nicht verwendet werden.
-	Wikireg.new(:small, %r{<small>(.*)</small>},
-								Proc.new{|m, oo, log| 
-										[	oo.inline(m.pre_match, log), 
-											element(:small, {}, oo.inline(m[1], log )),
-											oo.inline(m.post_match, log)
-										]
-								} ),								
-	Wikireg.new(:stroke, %r{<s>(.*)</s>},
-								Proc.new{|m, oo, log| 
-										[	oo.inline(m.pre_match, log), 
-											element(:stroke, {}, oo.inline(m[1], log )),
-											oo.inline(m.post_match, log)
-										]
-								} ),								
-	#-	Textbaustein	{{...}}
-	#Standard: [[ legt Textbaustein an, {{ nutzt diesen
-	#	http://de.wikipedia.org/wiki/Wikipedia:Textbausteine/Schwesterprojekte
-	#-	http://de.wikipedia.org/wiki/Wikipedia:Textbausteine
-	Wikireg.new(:wikidef, /\[\[(.+?):(.*?)\]\]/,		
-										Proc.new{|m, oo, log| 
-										puts "wikidef #{m[1].inspect} obsolete, please use macro {{..|"
-											[	oo.inline(m.pre_match, log), 
-												oo.wikidef(m[1], m[2] ),
-												oo.inline(m.post_match, log)
-											]}
-									),
-	Wikireg.new(:wiki_macro, /\{\{(.+?)(\|(.*?))?\}\}/,		
-										Proc.new{|m, oo, log| 
-											[	oo.inline(m.pre_match, log), 
-												oo.wiki_macro(m[1], m[3] ),
-												oo.inline(m.post_match, log)
-											].delete_if{|e| ! e or e.respond_to?(:to_str) and /\A\s*\Z/m =~ e}
-											#[].delete(nil) may return nil -> use delete_if
-										}
-									),
-	#Problem: detect end of url without a end-character
+  #[[Bild:Dateiname|Zusatzinfos|Beschreibung]]
+  #Zusatzinfos:
+  #	-left
+  #	-right
+  Wikireg.new(:bild, /\[\[Bild:(.*?)\]\]/,
+                Proc.new{|m, oo, log| 
+                  parameter = m[1].split('|')
+                  [	oo.inline(m.pre_match, log),
+                    oo.wiki_bild( parameter.first, parameter[1..-1], log),
+                    oo.inline(m.post_match, log),
+                  ]
+              } ),
+  Wikireg.new(:file, /\[\[File:(.*)\]\]/,
+                Proc.new{|m, oo, log| 
+                  parameter = m[1].split('|')
+                  filename = parameter[0]
+                  if parameter.size > 1
+                    txt = "#{parameter.last}"
+                  else
+                    txt = File.basename(filename)
+                  end
+                  if  Wikireg.give_message? and ! File.exist?(filename)
+                    log.warn( "Link to unexisting local file #{filename} (from #{Dir.pwd})" ) if log.warn?
+                  end
+                  
+                  css = CSS.new()
+                  parameter[1..-2].each{|p|
+                    case p
+                      when 'size'
+                        txt << " (#{File.size(filename)/1024}KB)"	if File.exist?(filename)
+                      when /(.*)=>(.*)/
+                        css[$1] = $2
+                      else
+                        log.warn( "Wiki-File with unknown setting #{p}" ) if log.warn?
+                    end
+                  }
+                  #Result:
+                  [ 
+                    oo.inline(m.pre_match, log), 
+                    element(:a, { :href => filename, :alt => txt, :style => css  }, oo.inline(txt, log) ),
+                    oo.inline(m.post_match,log)
+                ]} ),
+  Wikireg.new(:label, %r{\[\[label:(.*)\]\]},
+                Proc.new{|m, oo, log| 
+                    [	oo.inline(m.pre_match, log), 
+                      element(:label, { :name => m[1]} ),
+                      oo.inline(m.post_match, log)
+                    ]
+                } ),
+  Wikireg.new(:ref, %r{<ref>(.*)</ref>},
+                Proc.new{|m, oo, log| 
+                puts "<ref> is obsolete, use {{footnote}}. To get footnotes set {{footnotes|ref}}"
+                    [	oo.inline(m.pre_match, log), 
+                      element(:footnote, { :groupid =>  'ref' }, oo.inline(m[1],log) ),
+                      oo.inline(m.post_match, log)
+                    ]
+                } ),
+  Wikireg.new(:bf_it, /''''(.*?)''''/,
+                Proc.new{|m, oo, log| [ oo.inline(m.pre_match, log), 
+                            element(:textbf, {}, element(:emph, {}, oo.inline(m[1], log) )),
+                            oo.inline(m.post_match, log)
+                ]} ),
+  Wikireg.new(:bf, /'''(.*?)'''/,
+                Proc.new{|m, oo, log| [ oo.inline(m.pre_match, log), 
+                            element(:textbf, {}, oo.inline(m[1], log)),
+                            oo.inline(m.post_match, log)
+                ]} ),
+  Wikireg.new(:it, /''(.*?)''/,
+                Proc.new{|m, oo, log| [ oo.inline(m.pre_match, log), 
+                            element(:emph, {}, oo.inline(m[1], log)),
+                            oo.inline(m.post_match, log)
+                ]} ),
+  #Soll in Wikipedia-Artikeln nicht verwendet werden.
+  Wikireg.new(:small, %r{<small>(.*)</small>},
+                Proc.new{|m, oo, log| 
+                    [	oo.inline(m.pre_match, log), 
+                      element(:small, {}, oo.inline(m[1], log )),
+                      oo.inline(m.post_match, log)
+                    ]
+                } ),								
+  Wikireg.new(:stroke, %r{<s>(.*)</s>},
+                Proc.new{|m, oo, log| 
+                    [	oo.inline(m.pre_match, log), 
+                      element(:stroke, {}, oo.inline(m[1], log )),
+                      oo.inline(m.post_match, log)
+                    ]
+                } ),								
+  #-	Textbaustein	{{...}}
+  #Standard: [[ legt Textbaustein an, {{ nutzt diesen
+  #	http://de.wikipedia.org/wiki/Wikipedia:Textbausteine/Schwesterprojekte
+  #-	http://de.wikipedia.org/wiki/Wikipedia:Textbausteine
+  Wikireg.new(:wikidef, /\[\[(.+?):(.*?)\]\]/,		
+                    Proc.new{|m, oo, log| 
+                    puts "wikidef #{m[1].inspect} obsolete, please use macro {{..|"
+                      [	oo.inline(m.pre_match, log), 
+                        oo.wikidef(m[1], m[2] ),
+                        oo.inline(m.post_match, log)
+                      ]}
+                  ),
+  Wikireg.new(:wiki_macro, /\{\{(.+?)(\|(.*?))?\}\}/,		
+                    Proc.new{|m, oo, log| 
+                      [	oo.inline(m.pre_match, log), 
+                        oo.wiki_macro(m[1], m[3] ),
+                        oo.inline(m.post_match, log)
+                      ].delete_if{|e| ! e or e.respond_to?(:to_str) and /\A\s*\Z/m =~ e}
+                      #[].delete(nil) may return nil -> use delete_if
+                    }
+                  ),
+  #Problem: detect end of url without a end-character
   #[uri text]
-	Wikireg.new(:url1, %r{\[\s*((?:https?://|\.|C:\\|C:\/|ftp:|mailto:|webcal://).*?)\s+(.*?)\s*\]},
-						Proc.new{|m, oo, log| 
-							#Check local files, but without anchor
-							if /\A\./ =~ m[1]	#local file
-								filename = oo.inputsource + m[1].split(/#/).first	
-							else
-								filename = m[1].split(/#/).first	
-							end
+  Wikireg.new(:url1, %r{\[\s*((?:https?://|\.|C:\\|C:\/|ftp:|mailto:|webcal://).*?)\s+(.*?)\s*\]},
+            Proc.new{|m, oo, log| 
+              #Check local files, but without anchor
+              if /\A\./ =~ m[1]	#local file
+                filename = oo.inputsource + m[1].split(/#/).first	
+              else
+                filename = m[1].split(/#/).first	
+              end
                             if Wikireg.give_message? and /\A(\.|\w:)/ =~ m[1] and ! File.exist?(filename)
                               log.warn( "Link to unexisting local file #{filename} (from #{Dir.pwd})" ) if log.warn?
-							end
-							link_url = m[1]
-							if /^\w:/	=~	link_url	#local file with absolut path
-								link_url = 'file://' + link_url
-							end
-							if m[2].size > 0
-								linktext = m[2]
-							else
-								linktext = m[1].sub(/http:\/\//, '').sub(/\/$/, '')
-							end
-							[ 		oo.inline(m.pre_match, log), 
-									element(:a, {:href=> link_url }, oo.inline(linktext, log) ),
-									oo.inline(m.post_match, log)
-							]
-						} 
-					),
+              end
+              link_url = m[1]
+              if /^\w:/	=~	link_url	#local file with absolut path
+                link_url = 'file://' + link_url
+              end
+              if m[2].size > 0
+                linktext = m[2]
+              else
+                linktext = m[1].sub(/http:\/\//, '').sub(/\/$/, '')
+              end
+              [ 		oo.inline(m.pre_match, log), 
+                  element(:a, {:href=> link_url }, oo.inline(linktext, log) ),
+                  oo.inline(m.post_match, log)
+              ]
+            } 
+          ),
   #uri	http...
-	Wikireg.new(:url2, %r{(https?://.*?)(\s|\Z)},
-								Proc.new{|m, oo, log| 
-												[ oo.inline(m.pre_match, log), 
-														#~ element(:a, {:href=> m[1]}, m[1] ),	#hier kein oo.inline
-														element(:url, {}, m[1] ),	#hier kein oo.inline
-														m[2],								#Space/CR
-														oo.inline(m.post_match, log)
-								]} ),
-	Wikireg.new(:wikilink, /\[\[(.+?)(\|(.*?))?\]\]/,
-	#~ Wikireg.new(:wikilink, /\[\[(.+?)\]\]/,
-								Proc.new{|m, oo, log| 
-											linktext = m[1]
-											#m[2] includes the |
-											if m[3]
-												linktext = m[3]
-											end
-											[ oo.inline(m.pre_match, log), 
-												element(:a, {:href=> m[1]}, 
-													oo.inline(linktext, log)
-												),
-												oo.inline(m.post_match, log)
-											]
-								} ),
+  Wikireg.new(:url2, %r{(https?://.*?)(\s|\Z)},
+                Proc.new{|m, oo, log| 
+                        [ oo.inline(m.pre_match, log), 
+                            #~ element(:a, {:href=> m[1]}, m[1] ),	#hier kein oo.inline
+                            element(:url, {}, m[1] ),	#hier kein oo.inline
+                            m[2],								#Space/CR
+                            oo.inline(m.post_match, log)
+                ]} ),
+  Wikireg.new(:wikilink, /\[\[(.+?)(\|(.*?))?\]\]/,
+  #~ Wikireg.new(:wikilink, /\[\[(.+?)\]\]/,
+                Proc.new{|m, oo, log| 
+                      linktext = m[1]
+                      #m[2] includes the |
+                      if m[3]
+                        linktext = m[3]
+                      end
+                      [ oo.inline(m.pre_match, log), 
+                        element(:a, {:href=> m[1]}, 
+                          oo.inline(linktext, log)
+                        ),
+                        oo.inline(m.post_match, log)
+                      ]
+                } ),
 ]
 
 #require 'LotusNotes.rb'
 WIKI_INLINE_REPLACEMENT_NOTES =	
-			Wikireg.new(:notes, /(Notes:.*?)(\s|\Z)/,	Proc.new{|m, oo, log| 
-										[
-											oo.inline( m.pre_match, log),
-											LN_Link.new( m[1] ).to_element,
-											m[2],
-											oo.inline( m.post_match, log ),
-										]})
+      Wikireg.new(:notes, /(Notes:.*?)(\s|\Z)/,	Proc.new{|m, oo, log| 
+                    [
+                      oo.inline( m.pre_match, log),
+                      LN_Link.new( m[1] ).to_element,
+                      m[2],
+                      oo.inline( m.post_match, log ),
+                    ]})
 
 WIKI_INLINE_REPLACEMENTS_SYMBOLS = [
-			#Problem: Native LaTeX with beamer and \only...
-			Wikireg.new(:arrow, /->/,
-								Proc.new{|m, oo, log| 
-									[	oo.inline(m.pre_match, log),
-										element(:rightarrow),
-										oo.inline(m.post_match, log),
-									]
-							} ),
-			Wikireg.new(:Arrow, /=>/,
-								Proc.new{|m, oo, log| 
-									[	oo.inline(m.pre_match, log),
-										element(:Rightarrow),
-										oo.inline(m.post_match, log),
-									]
-							} ),
-			]
+      #Problem: Native LaTeX with beamer and \only...
+      Wikireg.new(:arrow, /->/,
+                Proc.new{|m, oo, log| 
+                  [	oo.inline(m.pre_match, log),
+                    element(:rightarrow),
+                    oo.inline(m.post_match, log),
+                  ]
+              } ),
+      Wikireg.new(:Arrow, /=>/,
+                Proc.new{|m, oo, log| 
+                  [	oo.inline(m.pre_match, log),
+                    element(:Rightarrow),
+                    oo.inline(m.post_match, log),
+                  ]
+              } ),
+      ]
 
 WIKI_INLINE_REPLACEMENTS_UNDERSCORE = Wikireg.new(:underscore, /_/,
-								Proc.new{|m, oo, log| 
-									[	oo.inline(m.pre_match, log),
-										"\\_",
-										oo.inline(m.post_match, log),
-									]
-							} )
-							
+                Proc.new{|m, oo, log| 
+                  [	oo.inline(m.pre_match, log),
+                    "\\_",
+                    oo.inline(m.post_match, log),
+                  ]
+              } )
+              
 #require 'LotusNotes.rb'
 if defined? LN_Link
-	WIKI_INLINE_REPLACEMENTS << WIKI_INLINE_REPLACEMENT_NOTES
+  WIKI_INLINE_REPLACEMENTS << WIKI_INLINE_REPLACEMENT_NOTES
 end
 
 module Wiki_helper
-	#Transfer the input to a list.
-	#input can be
-	#-String
-	#-List
-	#-File	(if .rb, then the part after __END__ is taken)
-	#The method returns a list with lines, but no \n
-	def get_input( input,  lineoffset, close_it = false )
-		inputlist	= []
-		if input.is_a?(String)
-			#~ inputlist = input.split("\n")
-			#Convert to Array, but keep the \n
-			inputlist = input.split("\n")
-		elsif input.is_a?(Array)
-			inputlist = input.flatten.map{|l| l.chomp()}
-		elsif input.is_a?(File)
-			#If file is a ruby scriot, then the wiki-code in after __END__
-			if /\.rb\Z/ =~ input.path and $0 != input.path 
-				line = input.readline while line != "__END__\n"
-			end
-			lineoffset = input.lineno
-			inputlist << input.readlines.map{|l| l.chomp}
-			input.close if close_it
-		end
-		return inputlist, lineoffset
-	end
+  #Transfer the input to a list.
+  #input can be
+  #-String
+  #-List
+  #-File	(if .rb, then the part after __END__ is taken)
+  #The method returns a list with lines, but no \n
+  def get_input( input,  lineoffset, close_it = false )
+    inputlist	= []
+    if input.is_a?(String)
+      #~ inputlist = input.split("\n")
+      #Convert to Array, but keep the \n
+      inputlist = input.split("\n")
+    elsif input.is_a?(Array)
+      inputlist = input.flatten.map{|l| l.nil? ? '' : l.chomp()}
+    elsif input.is_a?(File)
+      #If file is a ruby scriot, then the wiki-code in after __END__
+      if /\.rb\Z/ =~ input.path and $0 != input.path 
+        line = input.readline while line != "__END__\n"
+      end
+      lineoffset = input.lineno
+      inputlist << input.readlines.map{|l| l.chomp}
+      input.close if close_it
+    end
+    return inputlist, lineoffset
+  end
 end
 #
 #Struct for wiki elements.
@@ -281,263 +281,345 @@ class Wikielements   < Struct.new('Wikielements', :first, :l1,:l2,:l3,:l4, :tab,
     end
 end
 
-
+#
+#Get text in wiki-format and build a docgenerator-version.
+#
 class Wikitext
-	#Read text and convert it to a Document.
-	def initialize(
-			options = {}
-		)
-		#convert from old interface
-		options = {
-			:wiki_inline_replacements	=> options
-		}	if options.is_a?(Array)
-		@options = {
-			:wiki_inline_replacements	=> WIKI_INLINE_REPLACEMENTS + WIKI_INLINE_REPLACEMENTS_SYMBOLS,
+  #
+  #Make short description for the Wiki-syntax
+  def self.help( version = :syntax)
+    hlp = []
+    hlp << "Wikitext.help #{version.inspect}"
+    hlp << "-------------------------------------"
+    case version
+      when :syntax
+        hlp << <<main
+Sections:
+  ==title==
+  ===subtitle===
+  ====subsubtitle====
+Lists:
+  * unordered
+  # ordered
+  description-like:
+    ;key
+    :entry
+Pictures:
+  [[Bild:path|options]]
+  For options use Wikitext.help(:img)
+Tabulars:
+  Use Wikitext.help(:tab) for details
+Specials:
+  ----  hrule
+main
+      when :img
+        hlp << <<main
+Pictures in Wikitext:
+  [[Bild:path|options]]
+The complete command must be in one line.  
+  Options:
+  - href=
+  - alt=
+  - imgclass=: Used for CSS-class (img)
+  - figureclass=: Used for CSS-class (span/div)
+  - left, right:  CSS: float
+  - aftertitle/beforetitle: Text before/after image
+  - thumb: Add a thumb in the text and link to picture
+  - \d*px: size/width 
+  - width=xx%  define width for img/includegraphics
+  - xx = : Used for CSS in img
+main
+    when :tab
+      hlp << <<tabhelp
+Tabulars in Wikitext:
+  {|taboptions
+  |[lineoptions|]
+  |-[newline-options]
+  |
+  |}
+taboptions:
+  - columns=: number of columns (required)
+  - columndescription:  For LaTeX
+  - border=:  HTML
+  - .* = (.*): Used for CSS
+newline-options  
+  - toprule
+  - midrule
+  - hline
+  - .* = (.*): Used for CSS
+lineoptions:
+  - colspan = 
+  - pos
+  - .* = (.*): Used for CSS
+
+Remark: If the text contains macros with | there is a bit confusion, 
+what is a parameter of the cell and whats part of the macro.
+
+Solution: Define the end of cell parameters with ||
+tabhelp
+      else
+        hlp << "Sorry, option #{version.inspect} unknown"
+      end
+    return hlp.join("\n")
+  end #help
+  #Read text and convert it to a Document.
+  def initialize(
+      options = {}
+    )
+    #convert from old interface
+    options = {
+      :wiki_inline_replacements	=> options
+    }	if options.is_a?(Array)
+    @options = {
+      :wiki_inline_replacements	=> WIKI_INLINE_REPLACEMENTS + WIKI_INLINE_REPLACEMENTS_SYMBOLS,
       :log => Log4r::Logger.new('Wikitext', Log4r::INFO),
-			:inputsource						=>	'./',
-			:parsetest 						=> false	#Make an immediate test for parsing
-		}.update(options)
-		@source	= []
-		#This rules can be extended via the accessors.
-		@wiki_inline_replacements	= @options[:wiki_inline_replacements]
-		@lineoffset	= 0	#for better debugging
-		@inputsource	= @options[:inputsource]
-		@log	= @options[:log]
+      :inputsource						=>	'./',
+      :parsetest 						=> false	#Make an immediate test for parsing
+    }.update(options)
+    @source	= []
+    #Hash with all footnote groups
+    @footnotegroups = {}
+    #This rules can be extended via the accessors.
+    @wiki_inline_replacements	= @options[:wiki_inline_replacements]
+    @lineoffset	= 0	#for better debugging
+    @inputsource	= @options[:inputsource]
+    @log	= @options[:log]
     @log.outputters = Log4r::StdoutOutputter.new('log_stdout') if  @log.outputters.empty?
-		self	<<	@options[:content]	if @options[:content]
-		@parent	= self
-	end
-	#Line offset. 
-	#Is used as initial value in << 
-	attr_writer :lineoffset
-	#Used for relative filecheck
-	attr_accessor :inputsource
-	#Array with the rules for the inline elements (like text formatting...)
-	#Can be extended/replaces by this accessor
-	#
-	#Don't include arrays. elements must be 'Wikireg'.
-	attr_reader :wiki_inline_replacements
+    self	<<	@options[:content]	if @options[:content]
+    @parent	= self
+  end
+  #Line offset. 
+  #Is used as initial value in << 
+  attr_writer :lineoffset
+  #Used for relative filecheck
+  attr_accessor :inputsource
+  #Array with the rules for the inline elements (like text formatting...)
+  #Can be extended/replaces by this accessor
+  #
+  #Don't include arrays. elements must be 'Wikireg'.
+  attr_reader :wiki_inline_replacements
   #Logger
-	attr_reader :log
-	#Element, where the wiki test belongs to.
-	#Can be used in the procs insiede a wikirule.
-	attr_accessor :parent
-	#Wiki-Code, which is translated to to_element.
-	#Source is an array 
-	attr_accessor :source
-	
-	include Wiki_helper
-	#Add contents to Wiki-Text
-	def <<( input )
-		inputlist, lineoffset =  get_input( input,  @lineoffset )
-		#The immediate parsing may help, when an error occurs.
-		#The immediat parsing returns error messages with correct lineoffsets.
-		#(On the other side, it may helt to see the @source itself)
-		wiki2doc( inputlist.join("\n"), lineoffset ) if @options[:parsetest] == true
-		@source.concat(inputlist)
-		return self
-	end
-	#Prepare output for docgenerator.
+  attr_reader :log
+  #Element, where the wiki test belongs to.
+  #Can be used in the procs insiede a wikirule.
+  attr_accessor :parent
+  #Wiki-Code, which is translated to to_element.
+  #Source is an array 
+  attr_accessor :source
+  
+  include Wiki_helper
+  #Add contents to Wiki-Text
+  def <<( input )
+    inputlist, lineoffset =  get_input( input,  @lineoffset )
+    #The immediate parsing may help, when an error occurs.
+    #The immediat parsing returns error messages with correct lineoffsets.
+    #(On the other side, it may helt to see the @source itself)
+    wiki2doc( inputlist.join("\n"), lineoffset ) if @options[:parsetest] == true
+    @source.concat(inputlist)
+    return self
+  end
+  #Prepare output for docgenerator.
   #
   #Attention! to_doc uses another logger then the wiki.
   #If it should be the same, it must be added at definition of the wiki.
-	def to_doc( target, options = {} )
+  def to_doc( target, options = {} )
     o = Docgenerator_logger.set_option_defaults(options)
     o[:log].debug("enter to_doc for Wikitext #{self.inspect}") if o[:log].debug?
-    Footnotegroup.clear()
-		doc = wiki2doc( @source.join("\n") )  #return lists of element
+    @footnotegroups = {}  #Avoid the multiple additions to groups (this makes parallel processing inpossible!)
+    doc = wiki2doc( @source.join("\n") )  #return lists of element
     doc.to_doc(target, options )
-	end
-	
-	#
-	#Method is called for wiki-structures like
-	#	[[key:value]]
-	#This can be used to adapt the wiki for special usages.
-	#
-	#This is a inline replacement.
-	#The return code is added at the location, where it is defined
-	def wikidef( key, value )
+  end #Wikitext.to_doc
+  
+  #
+  #Method is called for wiki-structures like
+  #	[[key:value]]
+  #This can be used to adapt the wiki for special usages.
+  #
+  #This is a inline replacement.
+  #The return code is added at the location, where it is defined
+  def wikidef( key, value )
       @log.warn("#{self.class}#wikidef #{key}: #{value} in line #{@lineno}" ) if log.warn?
-			return value
-	end
-	#Include a picture	
-	#	[[Bild:Dateiname|Zusatzinfos|Beschreibung]]
-	#Zusatzinfos:
-	#	-left/right
-	#	-___px	scale the pic. When used in combination with thumb, a pic "widht-picname) is searched.
-	#	-thumb	(usefull in combination with href or width=50%)
-	#figure_type:
-	#The picture is framed by this value.
-	#When you use :div, you can't make inline-Pics.
-	#:span can be used also as float (HTML)
-	#Correct LaTeX: figure (or not?
-	def	wiki_bild( picname, parameter, log, figure_type = :span)
-		thumb	= false	#Use thumb instead
-		href		= false	#make pic clickabe
-		figure = element(figure_type, { :style	=>	css_fig	= CSS.new() }).cR
-		css_img	= CSS.new()
-		option = { :src => picname, :style => css_img  }	#Options for img
-		before_img	= []
-		after_img	= []
-			
-		parameter.each{|p|
-			case p
-				when /href=(.*)/;						href	=	$1
-				when /alt=(.*)/;						option[:alt] =	$1
-				when /imgclass=(.*)/;				option[:class]	=	$1
-				when /figureclass=(.*)/;			figure[:class]	<<	$1
-				when /^class=(.*)/;					option[:class]	=	$1	#old
-				when 'left', 'right'
-					css_fig[:float] = p
-				when /aftertitle(=(.*))*/
-					after_img << element(:br, { :clear => 'all' } ).cr
-					after_img << $2
-				when /beforetitle(=(.*))*/
-					before_img << $2
-					after_img << element(:br, { :clear => 'all' } ).cr
-				when /thumb(=(.*))*/
-					#Add a thumb in the text and link to picture
-					thumb	= true	#look later for width-picname
-					thumb	= $2	if $2
-					if File.exist?( @inputsource + picname ) and !href
-						href = picname
-					end
-				when /\A\d*px\Z/		#size
-					option[:width] = p
-				when /(width)=(.*)/
-					css_img[$1] = $2
-					w = $2	#store it, $2 is replaced in next regex.
-					case w
-						when /100%/
-							option[:width] = "\\textwidth"
-						when /\A(\d+)%/
-							option[:width] = "0.#{$1}\\textwidth"
-						else
-							option[:width] = w
-						end
-				when /(.*)=(.*)/
-					css_img[$1] = $2
-				else
-					log.warn( "Wiki-Picture with unknown setting #{p}" ) if log.warn?
-			end
-		}
-		
-		bild = []
-		bild = element(:a, {:href=>href }).cr	if href
-		
-		figure	<< before_img	if ! before_img.empty?
-		figure	<< bild
-		figure	<< after_img	if ! after_img.empty?
+      return value
+  end
+  #Include a picture	
+  #	[[Bild:Dateiname|Zusatzinfos|Beschreibung]]
+  #Zusatzinfos:
+  #	-left/right
+  #	-___px	scale the pic. When used in combination with thumb, a pic "widht-picname) is searched.
+  #	-thumb	(usefull in combination with href or width=50%)
+  #figure_type:
+  #The picture is framed by this value.
+  #When you use :div, you can't make inline-Pics.
+  #:span can be used also as float (HTML)
+  #Correct LaTeX: figure (or not?
+  def	wiki_bild( picname, parameter, log, figure_type = :span)
+    thumb	= false	#Use thumb instead
+    href		= false	#make pic clickabe
+    figure = element(figure_type, { :style	=>	css_fig	= CSS.new() }).cR
+    css_img	= CSS.new()
+    option = { :src => picname, :style => css_img  }	#Options for img
+    before_img	= []
+    after_img	= []
+      
+    parameter.each{|p|
+      case p
+        when /href=(.*)/;						href	=	$1
+        when /alt=(.*)/;						option[:alt] =	$1
+        when /imgclass=(.*)/;				option[:class]	=	$1
+        when /figureclass=(.*)/;			figure[:class]	<<	$1
+        when /^class=(.*)/;					option[:class]	=	$1	#old
+        when 'left', 'right'
+          css_fig[:float] = p
+        when /aftertitle(=(.*))*/
+          after_img << element(:br, { :clear => 'all' } ).cr
+          after_img << $2
+        when /beforetitle(=(.*))*/
+          before_img << $2
+          after_img << element(:br, { :clear => 'all' } ).cr
+        when /thumb(=(.*))*/
+          #Add a thumb in the text and link to picture
+          thumb	= true	#look later for width-picname
+          thumb	= $2	if $2
+          if File.exist?( @inputsource + picname ) and !href
+            href = picname
+          end
+        when /\A\d*px\Z/		#size
+          option[:width] = p
+        when /(width)=(.*)/
+          css_img[$1] = $2
+          w = $2	#store it, $2 is replaced in next regex.
+          case w
+            when /100%/
+              option[:width] = "\\textwidth"
+            when /\A(\d+)%/
+              option[:width] = "0.#{$1}\\textwidth"
+            else
+              option[:width] = w
+            end
+        when /(.*)=(.*)/
+          css_img[$1] = $2
+        else
+          log.warn( "Wiki-Picture with unknown setting #{p}" ) if log.warn?
+      end
+    }
+    
+    bild = []
+    bild = element(:a, {:href=>href }).cr	if href
+    
+    figure	<< before_img	if ! before_img.empty?
+    figure	<< bild
+    figure	<< after_img	if ! after_img.empty?
 
-		if thumb	== true
-			if File.exist?( "#{option[:width]}-#{option[:src]}" )
-				thumb	= "#{option[:width]}-#{option[:src]}"
-			else
-				thumb = picname
-			end									
-		end
-		option[:src] 	= thumb if thumb
-		
-		if /^(http|file|.:\/|\/)/ =~ option[:src]
-			src = option[:src]
-		else
-			src = @inputsource + option[:src]
-		end
-		if /^http/ !~ src and ! File.exist?( (src).sub(%r{file:\/\/}, '') )
-			log.warn( "Wikireg:bild: Picture #{option[:src]} not found (check from #{Dir.pwd} #{inputsource})" ) if log.warn?
-		end
-		if thumb and ! File.exist?( @inputsource + thumb )
-			log.warn( "Wikireg:bild: Thumb #{thumb} not found (check from #{Dir.pwd} #{inputsource})" ) if log.warn?
-		end
-		if href and /^http:/!~ href and ! File.exist?( @inputsource + href )
-			log.warn("Wikireg:bild: reference #{href} not found (check from #{Dir.pwd} #{inputsource})" ) if log.warn?
-		#~ puts Dir.pwd
-		#~ puts @inputsource.inspect
-		#~ puts href
-		#~ puts option[:src]
-		#~ puts '-'*10
-		end
-		
-		bild <<		element(:img, option )
-		figure
-	end	#wiki_bild
-		
-	#
-	#Analyses {{-Textmacros.
-	#If it is redefined, but want to keep the standard method,
-	#then you can call it via super in the else-branch of your case-command.
-	def wiki_macro( key, value, log = @log )
-		if value
-			val = value.split('|')
-		else
-			val	= []
-		end
-		case key
-			when 'maketitle', 'author', 'title', 'date'
-				val = val[0]
-				return [
-					element( key.to_sym,{},val ).cr,
-					]
-			when 'Commons'
-				return [
-					element(:a, { :href => "http://commons.wikimedia.org/wiki/#{val[0]}" }, "Commons: #{val[0]}" ).cr,
-					]
-			#~ when 'Wikibooks'
-				#~ #fixme language?
-				#~ return [
-					#~ element(:a, { :href => "http://en.wikibooks.org/wiki/#{val[0]}" }, "Commons: #{val[0]}" ).cr,
-					#~ ]
-			when 'newline'
-				if val.include?('clear')
-					return element(:br, {:clear=>'all'})
-				else
-					return element(:br)
-				end
-			when 'dmoz'
-				def dmoz_analyse(val)
-					if val[1]
-						catname = val[1]
-					else
-						catname = val[0].split(/\//).last.gsub(/_/, ' ')
-					end
-					cat = val[0].sub(%r{http://(www|editors)*.dmoz.org/}, '')
-					cat << '/' if cat[-1,1] != '/'
-					return cat, catname
-				end
-				cat, catname = dmoz_analyse(val)
-				return [
-					'Weitere Links zum Thema ',
-					element(:a, { :href => "http://dmoz.org/#{cat}" }, catname ),
-					' im Open Directory Project'
-					]
-			when 'dmozed'
-				#fixme: Umlaute
-				cat, catname = dmoz_analyse(val)
-				return [
-							element(:a, { :href => "http://dmoz.org/#{cat}" }, catname ),
-							' ',
-							element(:a, { :href => "http://editors.dmoz.org/editors/editcat.cgi?cat=#{cat}" }, 
-								[ '(Edit)'])
-						]
-			#footnotes|groupid
-			when 'footnotes'
-				#~ value = self.object_id if ! value
-				value = nil if ! value
-				return Footnotegroup.get( value )
-			#footnote[groupid]
-			when /footnote(\[(.*)\])*/
-				#fixme footnotegroup?
-				#~ $2	? groupid = $2 : groupid = self.object_id
-				$2	? groupid = $2 : groupid = nil
-				return [
-						element(:footnote, { :groupid =>groupid }, self.inline(value, log) ),
-					]
-			when 'html'
-				return element(:htmlonly, {}, value )
-			when 'rubycode', 'rubyvar'	##Pfui, eval
-				log.warn( "#{self.class}#wiki_macro: eval in line #{@lineno} ('#{value}')" ) if log.warn?
-				#~ return eval(value)
-				return eval(value, binding, 'Wiki', @lineno)	
+    if thumb	== true
+      if File.exist?( "#{option[:width]}-#{option[:src]}" )
+        thumb	= "#{option[:width]}-#{option[:src]}"
+      else
+        thumb = picname
+      end									
+    end
+    option[:src] 	= thumb if thumb
+    
+    if /^(http|file|.:\/|\/)/ =~ option[:src]
+      src = option[:src]
+    else
+      src = @inputsource + option[:src]
+    end
+    if /^http/ !~ src and ! File.exist?( (src).sub(%r{file:\/\/}, '') )
+      log.warn( "Wikireg:bild: Picture #{option[:src]} not found (check from #{Dir.pwd} #{inputsource})" ) if log.warn?
+    end
+    if thumb and ! File.exist?( @inputsource + thumb )
+      log.warn( "Wikireg:bild: Thumb #{thumb} not found (check from #{Dir.pwd} #{inputsource})" ) if log.warn?
+    end
+    if href and /^http:/!~ href and ! File.exist?( @inputsource + href )
+      log.warn("Wikireg:bild: reference #{href} not found (check from #{Dir.pwd} #{inputsource})" ) if log.warn?
+    #~ puts Dir.pwd
+    #~ puts @inputsource.inspect
+    #~ puts href
+    #~ puts option[:src]
+    #~ puts '-'*10
+    end
+    
+    bild <<		element(:img, option )
+    figure
+  end	#wiki_bild
+    
+  #
+  #Analyses {{-Textmacros.
+  #If it is redefined, but want to keep the standard method,
+  #then you can call it via super in the else-branch of your case-command.
+  def wiki_macro( key, value, log = @log )
+    if value
+      val = value.split('|')
+    else
+      val	= []
+    end
+    case key
+      when 'maketitle', 'author', 'title', 'date'
+        val = val[0]
+        return [
+          element( key.to_sym,{},val ).cr,
+          ]
+      when 'Commons'
+        return [
+          element(:a, { :href => "http://commons.wikimedia.org/wiki/#{val[0]}" }, "Commons: #{val[0]}" ).cr,
+          ]
+      #~ when 'Wikibooks'
+        #~ #fixme language?
+        #~ return [
+          #~ element(:a, { :href => "http://en.wikibooks.org/wiki/#{val[0]}" }, "Commons: #{val[0]}" ).cr,
+          #~ ]
+      when 'newline'
+        if val.include?('clear')
+          return element(:br, {:clear=>'all'})
+        else
+          return element(:br)
+        end
+      when 'dmoz'
+        def dmoz_analyse(val)
+          if val[1]
+            catname = val[1]
+          else
+            catname = val[0].split(/\//).last.gsub(/_/, ' ')
+          end
+          cat = val[0].sub(%r{http://(www|editors)*.dmoz.org/}, '')
+          cat << '/' if cat[-1,1] != '/'
+          return cat, catname
+        end
+        cat, catname = dmoz_analyse(val)
+        return [
+          'Weitere Links zum Thema ',
+          element(:a, { :href => "http://dmoz.org/#{cat}" }, catname ),
+          ' im Open Directory Project'
+          ]
+      when 'dmozed'
+        #fixme: Umlaute
+        cat, catname = dmoz_analyse(val)
+        return [
+              element(:a, { :href => "http://dmoz.org/#{cat}" }, catname ),
+              ' ',
+              element(:a, { :href => "http://editors.dmoz.org/editors/editcat.cgi?cat=#{cat}" }, 
+                [ '(Edit)'])
+            ]
+      #footnotes|groupid
+      when 'footnotes'
+        #~ value = self.object_id if ! value
+        value = Footnotegroup::DEFAULTGROUPID unless value
+        return @footnotegroups[value]
+      #footnote[groupid]
+      when /footnote(\[(.*)\])*/
+        groupid = $2 ? $2 : Footnotegroup::DEFAULTGROUPID 
+        if ! @footnotegroups[groupid]
+          @footnotegroups[groupid] = Footnotegroup.new(groupid)
+        end
+        return [
+            element(:footnote, { :group => @footnotegroups[groupid] }, self.inline(value, log) ),
+          ]
+      when 'html'
+        return element(:htmlonly, {}, value )
+      when 'rubycode', 'rubyvar'	##Pfui, eval
+        log.warn( "#{self.class}#wiki_macro: eval in line #{@lineno} ('#{value}')" ) if log.warn?
+        #~ return eval(value)
+        return eval(value, binding, 'Wiki', @lineno)	
       when 'verbatimfile'
         if File.exist?( val.first )
           return element(:verbatim,
@@ -555,477 +637,492 @@ class Wikitext
           log.error( "#{self.class}#wiki_macro: File #{value} missing for filecontent in line #{@lineno}" ) if log.error?
         end
       #A symbol. The corresponding element must be defined.
-			when 'symbol';		return element(value.to_sym)
-			when 'backslash';		return element(:backslash )
-			when '^'; 					return element(:ensuremath, {}, element(:'^' ) )
-			when '>'; 					return element(:gt)
-			when '<'; 					return element(:lt)
-			when 'percent', '%';	return element(:percent )
-			when 'rbrace';			return element(:rbrace )
-			when '_';					return element(:underscore )
-			when ' ';					return element(:relax )
-			when 'lbrace';			return element(:lbrace )
-			when 'tilde',	'sim';	return element(:sim )
-			when 'math';				return element(:ensuremath,{}, value )
+      when 'symbol';		return element(value.to_sym)
+      when 'backslash';		return element(:backslash )
+      when '^'; 					return element(:ensuremath, {}, element(:'^' ) )
+      when '>'; 					return element(:gt)
+      when '<'; 					return element(:lt)
+      when '&'; 					return element(:'\&')
+      when 'percent', '%';	return element(:percent )
+      when 'rbrace';			return element(:rbrace )
+      when '_';					return element(:underscore )
+      when ' ';					return element(:relax )
+      when '...';					return element(:ldots )
+      when 'lbrace';			return element(:lbrace )
+      when 'tilde',	'sim';	return element(:sim )
+      when 'math';				return element(:ensuremath,{}, value )
       #>>>requires privat/affiliate.rb
-			when 'asin'
+      when 'asin'
         return Amazon.new.asin_in_iframe( value ) if defined? JPC
         log.error( "#{self.class}#wiki_macro: No privat/docgenerator_affiliate available (line #{@lineno})" ) if log.error?
         return ''
-			when 'amazon'		#~ {{amazon|produktlinie|keywords}}
+      when 'amazon'		#~ {{amazon|produktlinie|keywords}}
         return Amazon.make_link(val) if defined? JPC
         log.error( "#{self.class}#wiki_macro: No privat/docgenerator_affiliate available (line #{@lineno})" ) if log.error?
         return ''
-			when 'jpc'		#~ {{amazon|produktlinie|keywords}}
+      when 'jpc'		#~ {{amazon|produktlinie|keywords}}
         return JPC.make_link(val) if defined? JPC
         log.error( "#{self.class}#wiki_macro: No privat/docgenerator_affiliate available (line #{@lineno})" ) if log.error?
         return ''
       #<<<requires privat/affiliate.rb
-			when 'fixme'
-				log.info( "Fixme: #{value}" ) if log.info?
-				return element(:comment, {}, [ 'Fixme: ', value ] )
-			else
-				log.error( "#{self.class}#wiki_macro Key '#{key}' unknown in line #{@lineno} ('#{value}')" ) if log.error?
-				return value
-		end
-	end
+      when 'fixme'
+        log.info( "Fixme: #{value}" ) if log.info?
+        return element(:comment, {}, [ 'Fixme: ', value ] )
+      else
+        log.error( "#{self.class}#wiki_macro Key '#{key}' unknown in line #{@lineno} ('#{value}')" ) if log.error?
+        return value
+    end
+  end
 
 
-	#Little structure for use in  wiki2doc.
-	Wiki_line = Struct.new('Wiki_line', :type, :content, :lineno, :indent, :add_info)
-	#
-	#Parse the text and creates the elements of it.
-	#
-	def wiki2doc( txt, lineoffset = 0, log = @log )
-		(@wiki_inline_replacements	).each{|rule|
-			if ! rule.is_a?(Wikireg)
-				log.fatal( "Wikitext.wiki2doc: rule is no Wikireg #{rule.inspect}" ) if log.fatal?
-			end
-		}
+  #Little structure for use in  wiki2doc.
+  Wiki_line = Struct.new('Wiki_line', :type, :content, :lineno, :indent, :add_info)
+  #
+  #Parse the text and creates the elements of it.
+  #
+  def wiki2doc( txt, lineoffset = 0, log = @log )
+    (@wiki_inline_replacements	).each{|rule|
+      if ! rule.is_a?(Wikireg)
+        log.fatal( "Wikitext.wiki2doc: rule is no Wikireg #{rule.inspect}" ) if log.fatal?
+      end
+    }
 
-		lines = []
-		@lineno = lineoffset
-		collector		= nil	#collect content for other application
-		collectorline	= nil	#collect content for other application
-		
-		txt.each{|line|
-			if line.gsub!( /#~.*/, '')	#delete comments
-				#skip processing, if the line is now empty.
-				#Without this, empty paragraphs can be created.
-				next if line	== "\n"
-			end
-			@lineno += 1
+    lines = []
+    @lineno = lineoffset
+    collector		= nil	#collect content for other application
+    collectorline	= nil	#collect content for other application
+    
+    txt.each{|line|
+    
+      if line.gsub!( /#~.*/, '')	#delete comments
+        #skip processing, if the line is now empty.
+        #Without this, empty paragraphs can be created.
+        next if line	== "\n"
+      end
+      @lineno += 1
 
-			#if the content should be turned into new variant, do it here.
-			if collector
-				if /^<<</	=~ line	#close the collector
-					lines << Wiki_line.new(:collector, collector, collectorline )
-					collector = nil
-				else
-					collector << line.chomp	#collect content to collector
-				end
-				next
-			end
-			#Preparse. Detect line type and assign it
-			case line.chomp
-			#Example:
-			#>>>structogramm{title;width;height}
-			when /^>>>(.*)\{(.*)\}/
-				args = []
-				ctype = $1
-				args = $2.split(/[;]/)	if $2
-				collector = WikiCollector.create(ctype, args )
-				collectorline	= @lineno
-				if ! collector
+      #if the content should be turned into new variant, do it here.
+      if collector
+        if /^<<</	=~ line	#close the collector
+          lines << Wiki_line.new(:collector, collector, collectorline )
+          collector = nil
+        else
+          collector << line.chomp	#collect content to collector
+        end
+        next
+      end
+      #Preparse. Detect line type and assign it
+      case line.chomp
+      #Example:
+      #>>>structogramm{title;width;height}
+      when /^>>>(.*)\{(.*)\}/
+        args = []
+        ctype = $1
+        args = $2.split(/[;]/)	if $2
+        collector = WikiCollector.create(ctype, args )
+        collectorline	= @lineno
+        if ! collector
           log.error( "#{__FILE__}##{__LINE__}: Undefined Collector #{ctype.inspect} used. Take Array instead (line #{@lineno})" ) if log.error?
-					collector = []
-				end
-			#===[key]Titel===
-			when /\A(=+)(?:\[(.*?)\])?(.+?)(=+)\s*/	#:h1, :h2, :h3, :h4, :h5, :h6
-			#~ puts $1, $2, $3
-				if $1.size != $4.size
-					log.warn("#{__FILE__}: Heading problem #{$1} doesn't match <#{$3}> #{line.inspect}" ) if log.warn?
-				end
-				#Level starts with ==
-				#	=title= is not supported.
-				h_level = "h#{$1.size - 1}".to_sym
-				lines	<< Wiki_line.new(h_level, self.inline($3, log), @lineno, nil, $2)
-			when /^\s*$/ #empty line
-				lines	<< Wiki_line.new(:p,nil, @lineno)
-			when /^((?:\*|\#)+)(\s*)/	#:li
-				lines	<< Wiki_line.new(:li, self.inline($~.post_match, log), @lineno, $2.size, $1)
-			#Experiment f�r items in description
-			#~ when /^(:)?((?:\*|\#)+)(\s*)/	#:li
-			#~ puts '>' * 15
-			#~ puts line.inspect
-			#~ puts $1.inspect
-			#~ puts $2.inspect
-			#~ puts $3.inspect
-			#~ puts '<' * 15
-				#~ lines	<< Wiki_line.new(:li, self.inline($~.post_match, log), @lineno, $3.size, $2)
-			when /^;(\s*)/	#:dt
-				lines	<< Wiki_line.new(:dt, self.inline($~.post_match, log), @lineno, $1.size)
-			when /^:(\s*)/	#:dd
-				lastline = lines.last
-				if ! lastline
-					log.warn( "#{__FILE__}: Use ':' at start of wiki text. #{@lineno}" ) if log.warn?
-					lastline = Wiki_line.new()	#Avoid error with method type
-				end
-				#If there was already an indent before, loo back.
-				if lastline.type == :indent
-					#find first line before indent
-					lines.reverse.each{|line|
-						lastline = line
-						break if lastline.type != :indent 
-					}
-				end
-				if [:dt,:dd].include?(lastline.type)
-					lines	<< Wiki_line.new(:dd, self.inline($~.post_match, log), @lineno, $1.size)
-				else			#-> quote
-					lines	<< Wiki_line.new(:quote, self.inline($~.post_match, log), @lineno, $1.size)
-				end
-			when /^----$/	#:hr	#line
-				lines	<< Wiki_line.new(:hr,nil,@lineno)
-			when /^(\s+)/	#:indent	#can be: continuation of a list or a verbatim
-				lines	<< Wiki_line.new(:indent, $~.post_match, @lineno, $1.size)
-			when /^\{\|/	#:tab
-				lines	<< Wiki_line.new(:tabular,$~.post_match,@lineno)
-			when /^\|\}/	#:tabend
-				lines	<< Wiki_line.new(:tabular_end,$~.post_match,@lineno)
-			when /^\|-/	#:tabrow
-				lines	<< Wiki_line.new(:tabular_row,$~.post_match,@lineno)
-			when /^\|(.*\|)*(.*?)\s*$/	#:tabcell
-				par = $1
-				txt = $2
-				#if the text contains macros with | there is a bit confusion, 
-				#what is a parameter of the cell and whats part of the macro.
-				#
-				#Solution:
-				#Define the end of cell parameters with ||
-				if par and par =~ /\|\|/
-					par = $~.pre_match	#parameters only before ||
-					txt	= $~.post_match + txt	#txt all after ||
-				end
-				lines	<< Wiki_line.new(:tabular_cell	,self.inline(txt, log),@lineno,nil,par)
-			else
-				#~ puts "??\tUnknown line (#{__FILE__} line #{__LINE__})"
-				#~ puts "??\tUnknown line: #{line.inspect}"
-				#lines	<< Wiki_line.new(:text, self.inline(line, log), @lineno)
-				#Insert space at end of line, but before \n.
-				#Without, a line break results in HTML-Text without space between flow text
-				lines	<< Wiki_line.new(:text, self.inline("#{line.chomp} \n", log), @lineno)
-			end
-		}	#txt.each |line|
-		
-		if collector
+          collector = []
+        end
+      #===[key]Titel===
+      when /\A(=+)(?:\[(.*?)\])?(.+?)(=+)\s*/	#:h1, :h2, :h3, :h4, :h5, :h6
+      #~ puts $1, $2, $3
+        if $1.size != $4.size
+          log.warn("#{__FILE__}: Heading problem #{$1} doesn't match <#{$3}> #{line.inspect}" ) if log.warn?
+        end
+        #Level starts with ==
+        #	=title= is not supported.
+        h_level = "h#{$1.size - 1}".to_sym
+        lines	<< Wiki_line.new(h_level, self.inline($3, log), @lineno, nil, $2)
+      when /^\s*$/ #empty line
+        lines	<< Wiki_line.new(:p, nil, @lineno)
+      when /^((?:\*|\#)+)(\s*)/	#:li
+        lines	<< Wiki_line.new(:li, self.inline($~.post_match, log), @lineno, $2.size, $1)
+      #Experiment f�r items in description
+      #~ when /^(:)?((?:\*|\#)+)(\s*)/	#:li
+      #~ puts '>' * 15
+      #~ puts line.inspect
+      #~ puts $1.inspect
+      #~ puts $2.inspect
+      #~ puts $3.inspect
+      #~ puts '<' * 15
+        #~ lines	<< Wiki_line.new(:li, self.inline($~.post_match, log), @lineno, $3.size, $2)
+      when /^;(\s*)/	#:dt
+        lines	<< Wiki_line.new(:dt, self.inline($~.post_match, log), @lineno, $1.size)
+      when /^:(\s*)/	#:dd
+        lastline = lines.last
+        if ! lastline
+          log.warn( "#{__FILE__}: Use ':' at start of wiki text. #{@lineno}" ) if log.warn?
+          lastline = Wiki_line.new()	#Avoid error with method type
+        end
+        #If there was already an indent before, loo back.
+        if lastline.type == :indent
+          #find first line before indent
+          lines.reverse.each{|line|
+            lastline = line
+            break if lastline.type != :indent 
+          }
+        end
+        if [:dt,:dd].include?(lastline.type)
+          lines	<< Wiki_line.new(:dd, self.inline($~.post_match, log), @lineno, $1.size)
+        else			#-> quote
+          lines	<< Wiki_line.new(:quote, self.inline($~.post_match, log), @lineno, $1.size)
+        end
+      when /^----$/	#:hr	#line
+        lines	<< Wiki_line.new(:hr,nil,@lineno)
+      when /^(\s+)/	#:indent	#can be: continuation of a list or a verbatim
+        lines	<< Wiki_line.new(:indent, $~.post_match, @lineno, $1.size)
+      when /^\{\|/	#:tab
+        lines	<< Wiki_line.new(:tabular,$~.post_match,@lineno)
+      when /^\|\}/	#:tabend
+        lines	<< Wiki_line.new(:tabular_end,$~.post_match,@lineno)
+      when /^\|-/	#:tabrow
+        lines	<< Wiki_line.new(:tabular_row,$~.post_match,@lineno)
+      when /^\|(.*\|)*(.*?)\s*$/	#:tabcell
+        par = $1
+        txt = $2
+        #if the text contains macros with | there is a bit confusion, 
+        #what is a parameter of the cell and whats part of the macro.
+        #
+        #Solution:
+        #Define the end of cell parameters with ||
+        if par and par =~ /\|\|/
+          par = $~.pre_match	#parameters only before ||
+          txt	= $~.post_match + txt	#txt all after ||
+        end
+        lines	<< Wiki_line.new(:tabular_cell	,self.inline(txt, log),@lineno,nil,par)
+      else
+        #~ puts "??\tUnknown line (#{__FILE__} line #{__LINE__})"
+        #~ puts "??\tUnknown line: #{line.inspect}"
+        #lines	<< Wiki_line.new(:text, self.inline(line, log), @lineno)
+        #Insert space at end of line, but before \n.
+        #Without, a line break results in HTML-Text without space between flow text
+        lines	<< Wiki_line.new(:text, self.inline("#{line.chomp} \n", log), @lineno)
+      end
+    }	#txt.each |line|
+    
+    if collector
       log.error( "#{__FILE__}##{__LINE__}: Content Collector not closed (start in line #{collectorline}" ) if log.error?
-		end
-		
-		elements	= []	#main container
-		lists			={}	#lists.
-		lines.each{|line|
-			case	line.type
-			when	:h1, :h2, :h3, :h4, :h5, :h6
-				elements	<< element( line.type,{},line.content).cr
-				if line.add_info
-					elements.last[:id] << line.add_info
-				end
-				#~ elements	<< element( line.type,{},self.inline(line.content, log)).cr
-			when :p	#new paragraph
-			#fixme:  how to detect new paragraph or continuation of item/pre/verbatim
-				if !	elements.last		#Start wiki
-					elements	<< element( :p ).cr
-				elsif	elements.last.is_a?(:p) and ! elements.last.content?
-					#There is already an empty new par, we can use it.
-				elsif	elements.last.is_a?(ListEnvironment) 
-					#The next indent decides, if we need a new paragraph or continue in the last item.
-					elements.last.content.last	<< nil	#Add neutral flag for new paragraph
-				else
-					elements	<< element( :p ).cr
-				end
-			when :hr
-					elements	<< element( :hr ).cr
-			when :text
-				if ! elements.last or ! elements.last.is_a?(:p)
-					elements	<< element( :p ).cr
-				end
-				elements.last	<< line.content
-			when :li
-				if ! elements.last.is_a?(ListEnvironment)	#ListEnvironment can be also a :dl
-						lists				= {}	#delete all lists to start fresh
-				end
-				#~ puts "-----#{line.add_info}\t#{line.content.inspect}\t#{lists.keys.inspect}"
-				listtype	= ''
-				loclist	= {}	#temporary list of lists. will be stored in 'lists'
-				1.upto(line.add_info.size){|level|
-					leveltyp = line.add_info[0..level-1]	#typ of listhirarchie
-					if	lists[leveltyp]	#list already defined
-						loclist[leveltyp]	= lists[leveltyp]
-						loclist[leveltyp]	<< element(:li,{}, line.content).cR if leveltyp == line.add_info
-					else	#create new list
-						case line.add_info[-1,1]
-						when '*'
-							list_type = :ul
-						when '#'
-							list_type = :ol
-						else
-							log.error( "#{self.class}#wiki2doc: Unknown list type #{v}" ) if log.error?
-						end
-						loclist[leveltyp]	= element( list_type ).CR
-						#include first item in list
-						loclist[leveltyp] << li = element(:li,{}).cR	#add first item line
-						li << line.content	if leveltyp == line.add_info	#add content to item line
-						#Include list
-						if level == 1	#Add first list to element-list
-							elements << loclist[leveltyp] 
-						elsif leveltyp == line.add_info	#add new list to previous list
-							loclist[line.add_info[0,level-1]].content.last << loclist[leveltyp]
-						end
-					end
-				}
-				#copy lists and delete all other lists (so we get level changes)
-				lists	= loclist
-			when :dt
-				#~ lists	= {}	#mixture dl and ul/ol not possible actual
-				if ! elements.last.is_a?(:dl)
-					elements	<< element(:dl).cR
-					lists[':'] = elements.last
-				end
-				elements.last	<< element(:dt,{},line.content ).cr
-			when :dd
-				if ! elements.last.is_a?(:dl)
+    end
+    
+    elements	= []	#main container
+    lists			={}	#lists.
+    lines.each{|line|
+      case	line.type
+      when	:h1, :h2, :h3, :h4, :h5, :h6
+        elements	<< element( line.type,{},line.content).cr
+        if line.add_info
+          elements.last[:id] << line.add_info
+        end
+        #~ elements	<< element( line.type,{},self.inline(line.content, log)).cr
+      when :p	#new paragraph
+        #fixme:  how to detect new paragraph or continuation of item/pre/verbatim
+        if !	elements.last		#Start wiki
+          elements	<< element( :p ).cr
+        elsif	elements.last.is_a?(:p) and elements.last.content.empty?
+          #There is already an empty new par, we can use it.
+        elsif	elements.last.is_a?(ListEnvironment) 
+          #The next indent decides, if we need a new paragraph or continue in the last item.
+          elements.last.content.last	<< nil	#Add neutral flag for new paragraph
+        else
+          elements	<< element( :p ).cr
+        end
+      when :hr
+          elements	<< element( :hr ).cr
+      when :text
+        if ! elements.last or ! elements.last.is_a?(:p)
+          elements	<< element( :p ).cr
+        end
+        elements.last	<< line.content
+      when :li
+        if ! elements.last.is_a?(ListEnvironment)	#ListEnvironment can be also a :dl
+            lists				= {}	#delete all lists to start fresh
+        end
+        #~ puts "-----#{line.add_info}\t#{line.content.inspect}\t#{lists.keys.inspect}"
+        listtype	= ''
+        loclist	= {}	#temporary list of lists. will be stored in 'lists'
+        1.upto(line.add_info.size){|level|
+          leveltyp = line.add_info[0..level-1]	#typ of listhirarchie
+          if	lists[leveltyp]	#list already defined
+            loclist[leveltyp]	= lists[leveltyp]
+            loclist[leveltyp]	<< element(:li,{}, line.content).cR if leveltyp == line.add_info
+          else	#create new list
+            case line.add_info[-1,1]
+            when '*'
+              list_type = :ul
+            when '#'
+              list_type = :ol
+            else
+              log.error( "#{self.class}#wiki2doc: Unknown list type #{v}" ) if log.error?
+            end
+            loclist[leveltyp]	= element( list_type ).CR
+            #include first item in list
+            loclist[leveltyp] << li = element(:li,{}).cR	#add first item line
+            li << line.content	if leveltyp == line.add_info	#add content to item line
+            #Include list
+            if level == 1	#Add first list to element-list
+              elements << loclist[leveltyp] 
+            elsif leveltyp == line.add_info	#add new list to previous list
+              loclist[line.add_info[0,level-1]].content.last << loclist[leveltyp]
+            end
+          end
+        }
+        #copy lists and delete all other lists (so we get level changes)
+        lists	= loclist
+      when :dt
+        #~ lists	= {}	#mixture dl and ul/ol not possible actual
+        if ! elements.last.is_a?(:dl)
+          elements	<< element(:dl).cR
+          lists[':'] = elements.last
+        end
+        elements.last	<< element(:dt,{},line.content ).cr
+      when :dd
+        if ! elements.last.is_a?(:dl)
           log.warn( "#{self.class}#wiki2doc(#{line.lineno}: :dl without :dt	(#{line.content.strip})" ) if log.warn?
-					elements	<< element(:dl).cr
-				end
-				elements.last	<< element(:dd,{},line.content).cr
-			when :quote
-				if ! elements.last.is_a?(:quote)
-					elements	<< element(:quote).cR
-				end
-				if line.content	=~ /^\s*$/	#Empty line
-					elements.last	<< element(:newline).cR
-				else
-					elements.last	<< line.content
-					elements.last	<< ' '
-				end
-			when :indent
-				#~ puts "#{self.class}#wiki2doc(#{line.lineno}: indent: #{line.indent}\t#{line.add_info}\t#{line.content}"				
-				#Check if the indent is part of a list item
-				if elements.last.is_a?(ListEnvironment)
-					lastlist = lists[lists.keys.max]	#Get last (deepest) list
-					lastitem	= lastlist.content.last
-					
-					case lastitem.content.last
-					when nil	#new paragraph
-						lastitem << element(:p, {}, self.inline(line.content, log)).cr
-					when Element	#add content to last element
-						lastitem.content.last	<< self.inline(line.content, log)
-					else	#add content to item line
-						lastitem	<< ' '
-						lastitem	<< self.inline(line.content, log)
-					end
-				elsif elements.last.is_a?(:dl)
-						lastitem	<< self.inline(line.content, log)
-				elsif !	elements.last.is_a?(:pre)
-					elements	<< element(:pre).cR
-				end				
-				if elements.last.is_a?(:pre)
-					elements.last	<< ('    ' * (line.indent - 1 )) + line.content + "\n"
-				end
-			when :tabular
-					if /longtable/ =~ line.content
-					elements	<< tab = element(:longtable, {:style=>CSS.new()}).CR
-					else
-					elements	<< tab = element(:tabular, {:style=>CSS.new()}).CR
-					end
-					if line.content	#options
-						options = line.content.split('|')
-						options.each{|opt|
-							case opt
-							when /columndescription\s*=\s*(.*)/
-								tab[:columndescription] << $1	#TeX-Format
-							when /columns\s*=\s*(.*)/
-								tab[:columns] << $1.to_i
-							when /border\s*=\s*(.*)/
-								tab[:border] << $1.to_i
-							when /(.*)\s*=\s*(.*)/
-								#~ puts "#{__FILE__}##{__LINE__}: #{opt}"	if ! tab[:style].content.first
-								tab[:style].content.first[$1] = $2
-							else
+          elements	<< element(:dl).cr
+        end
+        elements.last	<< element(:dd,{},line.content).cr
+      when :quote
+        if ! elements.last.is_a?(:quote)
+          elements	<< element(:quote).cR
+        end
+        if line.content	=~ /^\s*$/	#Empty line
+          elements.last	<< element(:newline).cR
+        else
+          elements.last	<< line.content
+          elements.last	<< ' '
+        end
+      when :indent
+        #~ puts "#{self.class}#wiki2doc(#{line.lineno}: indent: #{line.indent}\t#{line.add_info}\t#{line.content}"				
+        #Check if the indent is part of a list item
+        if elements.last.is_a?(ListEnvironment)
+          lastlist = lists[lists.keys.max]	#Get last (deepest) list
+          lastitem	= lastlist.content.last
+          
+          case lastitem.content.last
+          when nil	#new paragraph
+            lastitem << element(:p, {}, self.inline(line.content, log)).cr
+          when Element	#add content to last element
+            lastitem.content.last	<< self.inline(line.content, log)
+          else	#add content to item line
+            lastitem	<< ' '
+            lastitem	<< self.inline(line.content, log)
+          end
+        elsif elements.last.is_a?(:dl)
+            lastitem	<< self.inline(line.content, log)
+        elsif !	elements.last.is_a?(:pre)
+          elements	<< element(:pre).cR
+        end				
+        if elements.last.is_a?(:pre)
+          elements.last	<< ('    ' * (line.indent - 1 )) + line.content + "\n"
+        end
+      when :tabular
+          if /longtable/ =~ line.content
+          elements	<< tab = element(:longtable, {:style=>CSS.new()}).CR
+          else
+          elements	<< tab = element(:tabular, {:style=>CSS.new()}).CR
+          end
+          if line.content	#options
+            options = line.content.split('|')
+            options.each{|opt|
+              case opt
+              when /columndescription\s*=\s*(.*)/
+                tab[:columndescription] << $1.gsub(/!/, '|')	#TeX-Format
+              when /columns\s*=\s*(.*)/
+                tab[:columns] << $1.to_i
+              when /border\s*=\s*(.*)/
+                tab[:border] << $1.to_i
+              when /(.*)\s*=\s*(.*)/
+                #~ puts "#{__FILE__}##{__LINE__}: #{opt}"	if ! tab[:style].content.first
+                tab[:style].content.first[$1] = $2
+              else
                 log.warn( "#{self.class}#wiki2doc(#{line.lineno}:	options for table unknown: #{opt}" ) if log.warn?
-							end
-						}
-					end
-					#Add first row
-					elements.last	<< element(:tr, {} ).cr
-			when :tabular_end
-				elements	<< nil
-			when :tabular_row
-				if ! elements.last.is_a?(:tabular)
-					log.warn( "#{self.class}#wiki2doc(#{line.lineno}: Add row to non-tabular" ) if log.warn?
-				end
-				prev_row = elements.last.content.last
+              end
+            }
+          end
+          #Add first row
+          elements.last	<< element(:tr, {} ).cr
+      when :tabular_end
+        elements	<< nil
+      when :tabular_row
+        if ! elements.last.is_a?(:tabular)
+          log.warn( "#{self.class}#wiki2doc(#{line.lineno}: Add row to non-tabular" ) if log.warn?
+        end
+        prev_row = elements.last.content.last
         rowcss = CSS.new()
-				elements.last	<< element(:tr, { :style => rowcss } ).cr
-				if line.content	#options
-					options = line.content.split('|')
+        elements.last	<< element(:tr, { :style => rowcss } ).cr
+        if line.content	#options
+          options = line.content.split('|')
   #~ puts options.inspect
-					options.each{|opt|
-						case opt
-							when 'toprule';		prev_row.toprule
-							when 'midrule';		prev_row.midrule
-							when 'hline';			  prev_row.hline
-							when /(.+)=(.+)/		#CSS?
+          options.each{|opt|
+            case opt
+              when 'toprule';		prev_row.toprule
+              when 'midrule';		prev_row.midrule
+              when 'hline';			  prev_row.hline
+              when /(.+)=(.+)/		#CSS?
                 rowcss[$1] = $2
-							when /\A\s*\Z/		#empty option
-							else
+              when /\A\s*\Z/		#empty option
+              else
                 log.warn( "#{self.class}#wiki2doc(#{line.lineno}): Unknown line option #{opt.inspect}" ) if log.warn?
-						end
-					}
-				end
-			when :tabular_cell
-				cellcss = CSS.new()
-					colspan = 1
-					pos = 'c'
-					if line.add_info	#options
-						#fixme: Tabelle mit verschiedenen Optionen??
-						options = line.add_info.split('|')
-						options.each{|opt|
-							case opt
-							when /colspan\s*=\s*(.*)/
-								colspan = $1.to_i
-							when /pos\s*=\s*(.*)/
-								pos = $1
-							when /(.*?)\s*=\s*(.*)/
-								cellcss[$1] = $2
-							else
-								log.warn( "options for table cell unknown: #{opt}	(line #{line.lineno})" ) if log.warn?
-							end
-						}
-					end
-					row = elements.last.content.last
-					if colspan > 1
-						row	<<	element(:multicolumn, { :colspan => colspan, :style => cellcss, :pos => pos }, line.content).cr
-					else
-						row	<<	element(:td, {	:style => cellcss }, line.content).cr
-					end
-			when :collector
-				#~ if line.content.respond_to? :to_doc
-					#~ elements << line.content.to_element
-				#~ else
-					elements << line.content
-				#~ end
-			else
-				log.error("#{self.class}#wiki2doc(#{line.lineno}): New line type #{line.type.inspect} (#{line.content.inspect})" ) if log.error?
-				elements	<< element( line.type,{},self.inline(line.content, log)).cr
-			end
-		}
-		return elements
-	end	#wiki2doc
-	#Translate text for inline tags.
-	def inline( intext, log, subs = @wiki_inline_replacements )
-		return Wikitext.inline( intext, log, subs, self )
-	end
-	#Translate text for inline tags.
-	#
-	#This can also be used from "outside" to translate single lines.
-	#To keep the same environment if called via an object, the object is given in oo.
-	def self.inline( intext, log, subs = WIKI_INLINE_REPLACEMENTS,
-							oo = self)
-		subs.each{|rule|
-			if rule.regex =~ intext
-				if rule.proc.is_a?( Proc )
-					return rule.proc.call($~, oo, log)
-				else
-					return rule.proc
-				end
-			end
-		}
-		return intext
-	end
+            end
+          }
+        end
+      when :tabular_cell
+        cellcss = CSS.new()
+          colspan = 1
+          pos = 'c'
+          if line.add_info	#options
+            #fixme: Tabelle mit verschiedenen Optionen??
+            options = line.add_info.split('|')
+            options.each{|opt|
+              case opt
+              when /colspan\s*=\s*(.*)/
+                colspan = $1.to_i
+              when /pos\s*=\s*(.*)/
+                pos = $1
+              when /(.*?)\s*=\s*(.*)/
+                cellcss[$1] = $2
+              else
+                log.warn( "options for table cell unknown: #{opt}	(line #{line.lineno})" ) if log.warn?
+              end
+            }
+          end
+          row = elements.last.content.last
+          if colspan > 1
+            row	<<	element(:multicolumn, { :colspan => colspan, :style => cellcss, :pos => pos }, line.content).cr
+          else
+            row	<<	element(:td, {	:style => cellcss }, line.content).cr
+          end
+      when :collector
+        #~ if line.content.respond_to? :to_doc
+          #~ elements << line.content.to_element
+        #~ else
+          elements << line.content
+        #~ end
+      else
+        log.error("#{self.class}#wiki2doc(#{line.lineno}): New line type #{line.type.inspect} (#{line.content.inspect})" ) if log.error?
+        elements	<< element( line.type,{},self.inline(line.content, log)).cr
+      end
+    }
+    
+    #Delete empty paragraphs
+    elements.map!{|element|
+      if element.is_a?(:p) and element.content.empty?
+        nil #Delete empty paragraphs
+      else
+        element
+      end
+    }
+    
+    return elements
+  end	#wiki2doc
+  #Translate text for inline tags.
+  def inline( intext, log, subs = @wiki_inline_replacements )
+    return Wikitext.inline( intext, log, subs, self )
+  end
+  #Translate text for inline tags.
+  #
+  #This can also be used from "outside" to translate single lines.
+  #To keep the same environment if called via an object, the object is given in oo.
+  def self.inline( intext, log, subs = WIKI_INLINE_REPLACEMENTS,
+              oo = self)
+    subs.each{|rule|
+      if rule.regex =~ intext
+        if rule.proc.is_a?( Proc )
+          return rule.proc.call($~, oo, log)
+        else
+          return rule.proc
+        end
+      end
+    }
+    return intext
+  end
+  #Obsolete method  -don't use.
   def toccss()
     @log.error("Usage of obsolete toccss, use CSS_collection[:toc]")  if @log.error?
     return CSS_collection[:toc].style.to_html
   end
-	#Make a table of contents
-	#
-	#Options:
-	#- listtype: :ul or :ol
-	#- addlinks: Set label for each header.
-	def toc( i_options = {} )
-		options = {
-			:listtype	=> :ul,
-			:level		=> 4,
-			:startlevel	=> 1,
-			:addlinks	=> true
-			}.update(i_options)
-		uls = {}
-		uls[options[:startlevel]]	= element(options[:listtype])
-		@source.flatten.each{|line|
-			if /\A(=+)(?:\[(.*?)\])?(.+?)(=+)\s*\z/ =~ line	#:h1, :h2, :h3, :h4, :h5, :h6
-				level		= $1.size.to_i - 1
-				anker	= $2
-				titletext	= $3
-				#Entfernen von Wiki-Links im Titel.
-				titletext.sub!(/\[\..*\s+(.*)\]/, '\1')
-				
-				next if level > options[:level]
-				if level < options[:startlevel]
-					log.warn( "#{self.class}#toc: TOC starts at #{options[:startlevel]}, but level #{level} defined at #{line}" ) if log.warn?
-					next 
-				end
-				if anker
-					titel = element(:a, {:href=>"##{anker}"}, titletext)
-				elsif options[:addlinks]
-					#Build label for toc
-					toclabel = []
-					1.upto(level){|i|
-						if uls[i]
-							if i == level	#same level - add one for actual element
-								toclabel << uls[i].content.size + 1
-							else	#Previous level - use size
-								toclabel << uls[i].content.size
-							end
-						else	#First element on this level
-							toclabel << 1 
-						end
-					}					
-					#~ puts "toclabel <#{$3}>\t#{toclabel.inspect}\t#{toclabel.join('-')}"
-					titel = element(:a, {:href=>"##{toclabel.join('-')}"}, titletext)
-					line.sub!(/^(=+)/, "\\1[#{toclabel.join('-')}]")
-				else
-					titel = titletext
-				end
-				options[:startlevel].upto(6){|i|
-					#Create 'higher' sections (indicates a problem in the text)
-					if		i < level
-						if ! uls[i]
-							log.warn( "#{self.class}#toc: Sectioning jumps over level #{i} at #{line}" ) if log.warn?
-							uls[i-1].content.last << uls[i] = element(options[:listtype] ).Cr if uls[i-1]
-						end
-						if ! uls[i].content.last
-							uls[i] << element(:li,{}, '' ).cr
-						end
-					elsif	i == level
-						#Create new level if necessary
-						if ! uls[level]
-							uls[level-1].content.last << uls[level] = element(options[:listtype] ).Cr
-						end
-						#Add section title
-						uls[level] << element(:li,{}, titel ).cr
-					else
-						#delete lower levels of previous topic
-						uls[i] = nil
-					end
-				}
-			end
-		}
-		return element(:div, { :class => 'toc' }, uls[options[:startlevel]] ).CR
-	end
-	def footnotes()
-		footnotes	= Footnotegroup.get( self.object_id)
-		return footnotes
-	end
+  #Make a table of contents
+  #
+  #Options:
+  #- listtype: :ul or :ol
+  #- addlinks: Set label for each header.
+  def toc( i_options = {} )
+    options = {
+      :listtype	=> :ul,
+      :level		=> 4,
+      :startlevel	=> 1,
+      :addlinks	=> true,
+      :tocclass => 'toc',
+      }.update(i_options)
+    uls = {}
+    uls[options[:startlevel]]	= element(options[:listtype])
+    @source.flatten.each{|line|
+      if /\A(=+)(?:\[(.*?)\])?(.+?)(=+)\s*\z/ =~ line	#:h1, :h2, :h3, :h4, :h5, :h6
+        level		= $1.size.to_i - 1
+        anker	= $2
+        titletext	= $3
+        #Entfernen von Wiki-Links im Titel.
+        titletext.sub!(/\[\..*\s+(.*)\]/, '\1')
+        
+        next if level > options[:level]
+        if level < options[:startlevel]
+          log.warn( "#{self.class}#toc: TOC starts not at #{options[:startlevel]}, but level #{level} defined at #{line}" ) if log.warn?
+          next 
+        end
+        if anker
+          titel = element(:a, {:href=>"##{anker}"}, titletext)
+        elsif options[:addlinks]
+          #Build label for toc
+          toclabel = []
+          1.upto(level){|i|
+            if uls[i]
+              if i == level	#same level - add one for actual element
+                toclabel << uls[i].content.size + 1
+              else	#Previous level - use size
+                toclabel << uls[i].content.size
+              end
+            else	#First element on this level
+              toclabel << 1 
+            end
+          }					
+          #~ puts "toclabel <#{$3}>\t#{toclabel.inspect}\t#{toclabel.join('-')}"
+          titel = element(:a, {:href=>"##{toclabel.join('-')}"}, titletext)
+          line.sub!(/^(=+)/, "\\1[#{toclabel.join('-')}]")
+        else
+          titel = titletext
+        end
+        options[:startlevel].upto(6){|i|
+          #Create 'higher' sections (indicates a problem in the text)
+          if		i < level
+            if ! uls[i]
+              log.warn( "#{self.class}#toc: Sectioning jumps over level #{i} at #{line}" ) if log.warn?
+              uls[i-1].content.last << uls[i] = element(options[:listtype] ).Cr if uls[i-1]
+            end
+            if ! uls[i].content.last
+              uls[i] << element(:li,{}, '' ).cr
+            end
+          elsif	i == level
+            #Create new level if necessary
+            if ! uls[level]
+              uls[level-1].content.last << uls[level] = element(options[:listtype] ).Cr
+            end
+            #Add section title
+            uls[level] << element(:li,{}, titel ).cr
+          else
+            #delete lower levels of previous topic
+            uls[i] = nil
+          end
+        }
+      end
+    }
+    return element(:div, { :class => options[:tocclass] }, uls[options[:startlevel]] ).CR
+  end
+  def footnotes()
+    footnotes	= Footnotegroup.get( self.object_id)
+    return footnotes
+  end
 end
 
 #Wiki-Collector is a hash with collectors.
@@ -1035,64 +1132,64 @@ end
 #
 #Usage example: see code2structogramm
 class WikiCollector
-	@@variants	= {}
-	#Add a new collector type.
-	#
-	#Each collector must implement the following methods:
-	#-new without parameters.
-	#-<<				get lines of wiki-source
-	#-to_doc	return the result 
+  @@variants	= {}
+  #Add a new collector type.
+  #
+  #Each collector must implement the following methods:
+  #-new without parameters.
+  #-<<				get lines of wiki-source
+  #-to_doc	return the result 
   #See the two examples 
   #- WikiCollectorHTML
   #- WikiCollectorFilecontent
   #
-	def self.add(key, classtype)
-		if @@variants[key] 
-			puts "WikiCollector: Double assignment #{key.inspect}, #{classtype}"
-		end
-		if ! classtype.method_defined?(:'<<')
-			puts "WikiCollector: Collector <#{key.inspect}> doesn't support <<"
-			return false
-		end
-		if ! classtype.method_defined?(:to_doc)
-			puts "WikiCollector: Collector <#{key.inspect}> doesn't support to_doc"
-			return false
-		end
-		@@variants[key] = classtype
-	end
-	#Get an instance of the requested collector.
-	def self.create(key, arguments	= [] )
-		#~ puts "WikiCollector: request #{key.inspect}"
-		if @@variants[key.to_sym]
-			begin
-				return @@variants[key.to_sym].new(*arguments)
-			rescue	ArgumentError
-				puts "WikiCollector: Collector <#{key.inspect}> get wrong parameters"
-				return false
-			end
-		else
-			puts "WikiCollector: Collector <#{key}> not found (available: #{@@variants.keys.inspect})"
-			return nil
-		end
-	end
+  def self.add(key, classtype)
+    if @@variants[key] 
+      puts "WikiCollector: Double assignment #{key.inspect}, #{classtype}"
+    end
+    if ! classtype.method_defined?(:'<<')
+      puts "WikiCollector: Collector <#{key.inspect}> doesn't support <<"
+      return false
+    end
+    if ! classtype.method_defined?(:to_doc)
+      puts "WikiCollector: Collector <#{key.inspect}> doesn't support to_doc"
+      return false
+    end
+    @@variants[key] = classtype
+  end
+  #Get an instance of the requested collector.
+  def self.create(key, arguments	= [] )
+    #~ puts "WikiCollector: request #{key.inspect}"
+    if @@variants[key.to_sym]
+      begin
+        return @@variants[key.to_sym].new(*arguments)
+      rescue	ArgumentError
+        puts "WikiCollector: Collector <#{key.inspect}> get wrong parameters"
+        return false
+      end
+    else
+      puts "WikiCollector: Collector <#{key}> not found (available: #{@@variants.keys.inspect})"
+      return nil
+    end
+  end
 end	#WikiCollector	
 #
 #A little collector of "Plain-HTML".
 #
 class WikiCollectorHTML < Element
-	Element.add( [:wikicollectorhtml],  WikiCollectorHTML)
+  Element.add( [:wikicollectorhtml],  WikiCollectorHTML)
   #Start without parameters.
   #Can be called in a Wiki with:
   # >>>html{}
   #   here you can add plain HTML
   # <<<
-	def initialize()
-		@htmlcode	= []
-	end
+  def initialize()
+    @htmlcode	= []
+  end
   #Add another line from Wiki
-	def <<(content)
-		@htmlcode << content
-	end
+  def <<(content)
+    @htmlcode << content
+  end
   #
   #Return the content 'as is', but only for HTML
   def to_doc( target, options = {}  )
@@ -1102,44 +1199,60 @@ class WikiCollectorHTML < Element
       else
         ''
       end
-		#~ return element(:onlyhtml,{},@htmlcode).restrict_to(:html).to_doc(target)
-	end
-	#~ def to_html()
-		#~ return @htmlcode
-	#~ end
-	#~ def to_latex(); ''; 	end
-	#~ def to_wiki(); ''; 	end
-	#~ def to_text(); ''; 	end
+    #~ return element(:onlyhtml,{},@htmlcode).restrict_to(:html).to_doc(target)
+  end
+  #~ def to_html()
+    #~ return @htmlcode
+  #~ end
+  #~ def to_latex(); ''; 	end
+  #~ def to_wiki(); ''; 	end
+  #~ def to_text(); ''; 	end
 end	
 WikiCollector.add(:html, WikiCollectorHTML )
 
 if __FILE__ == $0
+  
 puts 'Use the unit test for complete test'
 
+puts Wikitext.help
+puts Wikitext.help(:img)
+puts Wikitext.help(:tab)
+
+    #~ wiki = Wikitext.new(:content => <<wiki
+#~ There are normal footnotes{{footnote|Like this one}}. But:
+#~ Here is a footnote in group 1{{footnote[group1]some remarks}}, and
+#~ a second footnote{{footnote[group1]more remarks}}.
+#~ In another group{{footnote[group2]Each group gets a name}}, we can define further remarks.
+
+#~ ----
+#~ Normal Footnotes:
+#~ {{footnotes}}    
+#~ ----
+#~ Footnote group 1:
+#~ {{footnotes|group1}}    
+#~ ----
+#~ Footnote group 2:
+#~ {{footnotes|group2}}    
+#~ wiki
+    #~ )
     wiki = Wikitext.new(:content => <<wiki
-There are normal footnotes{{footnote|Like this one}}. But:
-Here is a footnote in group 1{{footnote[group1]some remarks}}, and
-a second footnote{{footnote[group1]more remarks}}.
-In another group{{footnote[group2]Each group gets a name}}, we can define further remarks.
+vorher
+
+nachher
+nachher2
 
-----
-Normal Footnotes:
-{{footnotes}}    
-----
-Footnote group 1:
-{{footnotes|group1}}    
-----
-Footnote group 2:
-{{footnotes|group2}}    
+==test==
+drei
 wiki
-    )
+)
 puts '---------------------'
 
+
 #~ puts wiki.toc.inspect
 #~ puts wiki.toc.to_html
 #~ puts wiki.toc.to_wiki
 #~ puts '--------HTML-------------'
-#~ puts wiki.to_html
+puts wiki.to_html
 #~ puts '--------HTML-------------'
 #~ puts wiki.to_html
 #~ puts '--------LaTeX-------------'
@@ -1148,6 +1261,10 @@ puts '---------------------'
 #~ puts wiki.to_wiki
 #~ puts '--------Text-------------'
 #~ puts wiki.to_text
+
+doc = Document.new()
+doc.body << wiki
+doc.save('test.html')
 end