docgenerator 0.1.1 → 1.0.2

data/{docgenerator_attribute.rb → lib/docgenerator_attribute.rb}

@@ -1,6 +1,5 @@
 #Administrate attributes for elements.
 class Attribute
-	include Backlinks
 	@@settings	= {}
 	@@values		= {}
 	@@sortkey		= 99	#Just a counter to get identic positions between different program runs.
@@ -115,7 +114,6 @@ class Attribute
 		if ! self.allowed?( value )
 			puts "Attribute #{@name}: Illegal value #{value.inspect} in #{@element.inspect}"
 		end
-		set_backlink( value )
 		if unique? and @attr_content.size > 0
 			puts "Attribute #{@name}: More then one value added (#{value}) in #{@element.inspect}"
 			return self
@@ -129,14 +127,41 @@ class Attribute
 	#Return the content.
 	def to_s()
 	#~ def to_s( target = Document.target( self ) )
-		#list of documents, where this element is part of (normaly only one element)
-		if @part_of_doc.size == 0
-			@part_of_doc	= @element.part_of_doc	
-			set_backlink( @attr_content )
-		end
 		@attr_content.to_s()
 	end
 	def inspect()
 		return "<#Attribute #{@name} #{@attr_content.inspect} (in #{@element.ids}) >"
 	end
 end
+
+#Definition of HTML-Tags (Sublasses of Element).
+ATTR_LANG		= Attribute.create( [ :html ], ['en', 'de'] )
+#
+HTML_ATTR_CORE	= {	
+          :id		=> Attribute.create( [ :html ] ),
+          :class	=> Attribute.create( [ :html ] ),
+          :style	=> Attribute.create( [ :html ], [CSS, String]),	#fixm string raus
+          #~ :name	=> Attribute.create( [ :html ] ),
+          :title		=> Attribute.create( [ :html ] ) }
+HTML_ATTR_I18N	= {	
+          :lang		=> ATTR_LANG,
+          :dir		=> Attribute.create( [ :html ], ['ltr', 'rtl'] )
+        }
+HTML_ATTR_EVENTS = {	:onclick		=> Attribute.create( [ :html ] ), 
+          :ondblclick		=> Attribute.create( [ :html ] ), 
+          :onmousedown	=> Attribute.create( [ :html ] ),
+          :onmouseup	=> Attribute.create( [ :html ] ),
+          :onmouseover	=> Attribute.create( [ :html ] ),
+          :onmousemove	=> Attribute.create( [ :html ] ),
+          :onmouseout	=> Attribute.create( [ :html ] ), 
+          :onkeypress	=> Attribute.create( [ :html ] ),
+          :onkeyup		=> Attribute.create( [ :html ] ), 
+          :onkeydown	=> Attribute.create( [ :html ] )
+      }
+HTML_ATTR_ALL = {}
+HTML_ATTR_ALL.update(HTML_ATTR_I18N)
+HTML_ATTR_ALL.update(HTML_ATTR_EVENTS)
+HTML_ATTR_ALL.update(HTML_ATTR_CORE)
+
+HTML_ATTR_ALIGN	= Attribute.create( [ :html ], ['left', 'center', 'right', 'justify', 'char'] )
+HTML_ATTR_VALIGN	= Attribute.create( [ :html ], ['bottom', 'top', 'middle', 'baseline'] )

data/{docgenerator_characters.rb → lib/docgenerator_characters.rb}

@@ -1,3 +1,18 @@
+#Some Coding to prepare the unit tests
+#~ els = nil
+#~ DATA.each{|line|
+  #~ case line
+    #~ when /\A\s*#/ #skip
+    #~ when /Element.create\( \[(.*)\]/
+      #~ els = $1.split(',').map{|el| el.strip }
+    #~ when /:(html|latex|wiki|text)\s*=>\s*'(.+?)'/
+      #~ els.each{|el|
+      #~ puts "    assert_equal( '#{$2}', element(#{el}).to_#{$1})"
+      #~ }
+  #~ end
+#~ }
+
+#~ __END__
 #
 # Special Characters
 #

data/{docgenerator_css.rb → lib/docgenerator_css.rb}

@@ -14,9 +14,13 @@ class Style < Element
 	Element.add( [:style],  self)
 	#~ add_attributes( HTML_ATTR_ALL ) 
 	add_output( :latex,	'')	
+	add_output( :text,	'')	
+	add_output( :wiki,	'')	
 	#Prepare HTML-Output for Style-Tag.
 	#The values can be overwritten, if different CSS-Elements are inside.
-	def to_html()
+	def to_html( options = {} )
+    o = Docgenerator_logger.set_option_defaults(options)
+    o[:log].debug("Enter style.to_html") if o[:log].debug?
 		res =	""
 		res <<	"\n" if @crbefore
 		res <<	"<style type=\"text/css\">\n"
@@ -62,6 +66,7 @@ class CSS
 		'text-decoration' => ['underline', 'overline', 'line-through', 'blink', 'none'],
 		#Ausrichtung
 		'float'	=> ['left', 'right', 'none' ],
+    'display'  => ['inline'],
 		'text-align'	=> ['left', 'center', 'right', 'justify', 'char'],
 		'vertical-align'	=> ['top', 'middle','bottom','baseline','sub','super','text-top','text-bottom'],
 		'clear'			=> ['left', 'right','both','none'],	#Fortsetzung bei Textumfluss

data/{docgenerator_document.rb → lib/docgenerator_document.rb}

@@ -10,68 +10,71 @@ class Document
 	#-	article
 	#-	report
 	#-	book
-	def initialize( template = nil )
+	def initialize( settings = {} )
 		#Set template defaults
 		@template	= {
-			:html	=> DocumentTemplate[:html],
+			:html	  => DocumentTemplate[:html],
 			:latex	=> DocumentTemplate[:article],
 			:text		=> DocumentTemplate[:text],
 			:wiki		=> DocumentTemplate[:wiki],
 		}
-		self.set_template( template ) if template
+		@language	= 'ngerman' #default
+    @date  = nil
+
+    ##>>>>temporary check, old interface
+    #~ puts settings.inspect
+    if ! settings.is_a?(Hash)
+      #Make an exception to correct data
+      raise "Old interface for Document#new, use :template => "
+      settings = { :template => settings }
+    end
+    ##<<<<temporary check, old interface
+    @log = settings[:log]
+    @log = Log4r::Logger.new( 'Doc' ) unless @log
+
+		@meta	= {}	#some meta-Tags for HTML
 		@body	= element( :body )
 		@head	= element( :head )
 		#~ @body.part_of << self
 		#~ @head.part_of << self
-		@body.part_of_doc << self
-		@head.part_of_doc << self
-		@language	= 'ngerman'
 		@options	= []
-		@meta	= {}	#some meta-Tags for HTML
     #Flag to avoid double definition of docinfo()
     @docinfo_called = false
     @creator  = nil
-	end
-	#
-	#Set Template to Generate a target.
-	#
-	#Compatibility for old version:
-	#-If template is an array, each entry is used as a key for DocumentTemplate.
-	#
-	def set_template( template, target = :latex )
-		template = [ template ] if template.kind_of?( Symbol )
-		#Compatibility for older version: Template can be given direct
-		if template.kind_of?(String )
-			#~ puts "Set Template with string"
-			@template[target] = template
-			return
-		elsif template.kind_of?(Array )
-			template.each{|templ|
-				if SUPPORTED_LaTeX_TEMPLATES.include?( templ )
-					target = :latex
-				elsif SUPPORTED_HTML_TEMPLATES.include?( templ )
-					target = :html
-				elsif /text/ =~ templ.to_s or /txt/ =~ templ.to_s
-					target = :txt
-				else
-					puts "Unknown template conversion for #{templ}"
-					target = :latex
-				end
-				@template[target] = DocumentTemplate[templ]
-				if ! @template[target]
-					puts "Unknown template #{templ}, valid:\n\t#{DocumentTemplate.keys.join("\n\t")}"	#fixme raise
-				elsif ! @template[target].kind_of?(String )
-					puts "Template no string #{@template.inspect}"
-					@template[target] = @template[target].to_s
-				end
-			}
-		else
-			raise "Should set template, but don't know how #{template.inspect}"		
-		end
+
+    settings.each{|key, value|
+      case key
+        when 	:title, :author, :date, :keywords, :description, :creator, :language
+          self.send("#{key}=".to_sym, value)
+        when :shorttitle, :odp
+          self.meta( key, value )
+        when :template
+     			[value].flatten.each{|template|
+                case template
+                  when DocumentTemplate
+                    @template[template.target] = template
+                  when Symbol
+                    templ = DocumentTemplate[template]
+                    if ! templ.is_a?( DocumentTemplate )
+                      puts "Unknown template #{template}, valid:\n\t#{DocumentTemplate.keys.join("\n\t")}"	#fixme raise
+                    else
+                      @template[templ.target] = templ
+                    end
+                end 
+          } #templates
+        when :maketitle
+          @body << element(:maketitle ).cr
+        else
+          puts "Document.new: Unknown setting #{key.inspect} (=#{value.inspect})"
+      end
+    } #settings
+
 	end
 	#body and head are lists, containing elements.
 	attr_reader	:body, :head
 	attr_reader	:template
+  #Logger for the document
+	attr_reader	:log
 	#Document title
 	attr_accessor	:title
 	#Set document description
@@ -159,19 +162,22 @@ class Document
 	#Supported document types are:
 	#-	tex
 	#-	html
+	#-	(wiki)
+	#-	(text)
 	#Depending on a template, different results are created.
 	#
-	#The is a comparison between an already existing file and the new one.
+	#There is a comparison between an already existing file and the new one.
 	#To write a new version, the document must change and overwrite must be true.
 	#
 	#It is possible to give pairs of RegExp (pattern) and replacements to the result.
 	def save( filename, overwrite=false, replacements = {}  )
 	
 		if ! @template
-			puts "No template available to create #{filename}"
+			@log.error( "No template available to create #{filename}" ) if @log.error?
 			return false
 		end
 		
+    #Get old content for comparison
 		old = nil
 		prefix = [ 	nil, 
 				"Build by\t#{__FILE__}",
@@ -183,9 +189,7 @@ class Document
 				"#{PREFIX_ENDFLAG}"
 			].join("\n\t")
 		if File.exist?( filename )
-			f = File.new( filename )
-			old = f.readlines().to_s
-			f.close
+			old = File.read( filename )
 		end
 		#Determine the target document type, depending on extension.
 		extension = File.basename( filename ).split( /\./).last
@@ -199,11 +203,17 @@ class Document
 		when /wiki/
 			@target = :wiki
 		else
+			@log.fatal( "Unknown Extension #{extension} for #{File.basename( filename )}" ) if @log.fatal?
 			raise "Unknown Extension #{extension}"
 		end
 		
-		@@target = @target	if ! UNDER_CONSTRUCTION
-		new = to_element( @target, @template[@target], replacements )
+		new = to_doc( @target, {
+                    :template=> @template[target],
+                    :document => self,
+                    :filename => filename,
+                    :replacements => replacements,
+                    :log  => @log
+                    })
 		
 		case @target
 		when :latex
@@ -216,6 +226,7 @@ class Document
 		when :wiki
 			#~ new.squeeze!("\n")
 		else
+			@log.fatal( "Unknown target #{@target} for #{File.basename( filename )}" ) if @log.fatal?
 			raise "Unknown target #{@target}"
 		end
 		#Make it a bit more compact.
@@ -223,7 +234,7 @@ class Document
 		new.gsub!(/\n+\n\n/, "\n\n")
 		
 		if ! new.kind_of?( String )
-			puts "New is wrong type: #{new.inspect}"
+			@log.error( "New is wrong type: #{new.inspect}" ) if @log.error?
 		end
 		@target	= nil
 
@@ -234,12 +245,14 @@ class Document
 				answer = $stdin.gets()	if $stdin.tty? #nur bei call aus DOS-Box
 				if ! ( answer =~ /[YyjJ].*/ )
 					puts "Bye"
+          @log.info( "Overwrite #{filename} after confirmation" ) if @log.info?
 					return false
 				end
 			end	
 			f = File.new( filename, 'w' )
 			f << new
 			f.close
+      @log.info( "Save changed\t#{filename}") if @log.info?
 			puts "Save changed\t#{filename}"	if @@givemessage.include?(:change)
 			#Save copy of old version (attention, *.bak makes no control on tex or html)
 			#~ f = File.new( filename.sub( extension, 'bak'), 'w' )
@@ -248,6 +261,7 @@ class Document
 			Document.runtex( filename, @runtex ) if @runtex
 			return true
 		elsif old
+      @log.info("Unchanged\t#{filename}") if @log.info?
 			puts "Unchanged\t#{filename}" if @@givemessage.include?(:nochange)
 			return false
 		end		
@@ -261,18 +275,21 @@ class Document
 	#(used from Document#save to include some additional information).
 	#
 	#If the method is called directly to prpare document snipplets, you can use:
-	#	puts Document#to_element( :latex, '<<body>>')
+	#	puts Document#to_doc( :latex, '<<body>>')
 	#
 	#It is possible to give pairs of RegExp (pattern) and a replacement to the result.
-	def to_element( target, template=@template[target], replacements = {} )
-	
-		@@target = target	if ! UNDER_CONSTRUCTION
+	def to_doc( target, options )
+    #~ o = Docgenerator_logger.set_option_defaults(options)
+    options[:log].info( "Build document for #{target.inspect}" ) if options[:log].info?
+    template  = options[:template]
 		if ! template
-			puts "No template available to create #{target.inspect} #{self.class}"
+			options[:log].error( "No template available to create #{target.inspect} #{self.class}" ) if options[:log].error?
 			return ''
 		end
-		
-		new = template.dup
+    replacements = options[:replacements] || {}
+    options[:log].warn( "No filename given " ) if options[:log].warn? and ! options[:filename]
+
+		new = template.template
 		case target
 		when :latex
 			add_option( @language )
@@ -280,56 +297,36 @@ class Document
 		when :text
 		when :wiki
 		else
-			raise "Unknown Extension #{extension}"
+      options[:log].fatal( "Unknown target #{target} for #{options[:filename]}" ) if options[:log].fatal?
+      return ''
 		end
 		if ! new.kind_of?( String )
-			puts "New is wrong type: #{new.inspect}"
+			options[:log].error( "New is wrong type: #{new.inspect}") if options[:log].error?
 		end
 
 		@head	<< self.docinfo()
-		new.sub!( '<<head>>',	@head.to_s)
-		new.sub!( '<<body>>',	@body.to_s)
-		new.sub!( '<<classoptions>>',	@options.join(','))
+		new.sub!( '<<head>>',	@head.to_doc(target, options ))
+		new.sub!( '<<body>>',	@body.to_doc(target, options))
+		new.sub!( '<<classoptions>>',	@options.uniq.join(','))
 		
+    
 		replacements.each{|pattern, replace |
+      options[:log].info("Replace text #{pattern.source} with #{replace}" ) if options[:log].info?
 			new.gsub!( pattern, replace ) if replace
 		}
 		return new
-	end	#Document#to_element	
+	end	#Document#to_doc	
 	#Return the actual target type.
 	#Needed by Element#to_s to decide which method is used to prepare the output.
 	#
 	#The usage of this technic makes similar processing unposibble.
 	#Set in Document#save.
 	attr_reader :target
-	@@target	= nil
-	#Set a major output routine.
-	def Document.target=( target )
-		@@target = target
-	end
-	def Document.target( element )
-		return @@target if @@target	#Use global value for multiple outputs
-		case element.part_of_doc.size
-		when 1
-			return element.part_of_doc.first.target
-		when 0
-			puts "Document.target: No related document. Don't know which target to take #{element.inspect} line #{__LINE__}"
-			element.ancestors.flatten.each_with_index{|a,i|
-				puts "\tAncestor #{i}\t#{a.inspect}"
-				puts "\t\t\t#{a.ancestors.inspect}"
-			}
-			#~ puts caller()
-			return :text
-		else
-			puts "Multiple documents. Don't know which target to take #{element.inspect}"
-			element.part_of_doc.each{|d|	puts "\t#{d.inspect}" }
-			return :text
-		end
-	end
+  
 	#Call TeX and translate the file.
 	#Experimental
 	#Fixme: Chain
-	def Document.runtex( filename, format = :pdflatex )
+	def Document.runtex( filename, format = :xelatex )
 		begin
 			#~ require 'rtex'
 			require 'c:/usr/script/rtex/rtex'
@@ -339,9 +336,11 @@ class Document
 		end
 		#~ puts "Unknown texfile #{filename}" if ! filename
 		tex = Chain.new()
+    tex.xelatex() #default
 		case format
-		when :latex
-			tex.latex()
+		when :xelatex;  tex.xelatex()
+		when :pdflatex;  tex.pdflatex()
+		when :latex;  			tex.latex()
 		end
 		#~ Logger.level=3
 		tex.file = filename
@@ -352,7 +351,7 @@ class Document
 			return false
 		end
 	end
-	#Make some basic replacemnts for TeX.
+	#Make some basic replacements for TeX.
 	#There is no sense to use it with HTML.
 	#
 	#Better solution: Puts String into \path, \verb or similar.

data/{docgenerator_element.rb → lib/docgenerator_element.rb}

@@ -1,7 +1,15 @@
+#Extend all objects by the methods 
+#- to_doc
+#- to_html
+#- to_latex
+#- to_wiki
+#- to_text
+#Redefine is_a?:
+#Return true, when you test with a symbol.
 class Object
 	alias :old_is_a? :is_a?
 	#Redefine the standard is_a?
-	#Returns also true, if one of the ids is in testvalu
+	#Returns also true, if one of the ids is in testvalue
 	def is_a?( testvalue)
 		if testvalue.old_is_a?(Symbol)
 			if old_is_a?(Element)
@@ -13,7 +21,50 @@ class Object
 			return old_is_a?(testvalue)
 		end
 	end
+  #
+  # to_doc returns the object as a string.
+  # will be redefined for Element
+  #
+  def to_doc(target, options = {})
+    o = Docgenerator_logger.set_option_defaults(options)
+    str = ""
+    if self.is_a?(Element) and ! self.respond_to?(:to_doc)
+      o[:log].error( "Missing to_doc routine for #{self.class}") if o[:log].error?
+    end
+    if self.respond_to?(:to_str)
+      str << self.to_str
+    else
+      str << self.to_s
+    end
+    str
+  end
+  def to_text(options = {}); to_doc(:text, options);  end
+  def to_latex(options = {}); to_doc(:latex, options);  end
+  def to_html(options = {}); to_doc(:html, options);  end
+  def to_wiki(options = {}); to_doc(:wiki, options);  end
+end
+
+class Array
+  #
+  # Returns the element for each parameter
+  #
+  def to_doc(target, options = {})
+    o = Docgenerator_logger.set_option_defaults(options)
+    o[:log].debug("enter to_doc in array for #{target}") if o[:log].debug?
+    str = ""
+    self.each{|el|
+      begin
+        str << el.to_doc(target, o)
+      rescue ArgumentError
+        o[:log].fatal("ArgumentError to_doc for element <#{el.class}>") if o[:log].fatal?
+        str << el.to_doc(target)
+      end
+    }
+    return str
+  end
 end
+
+
 #This class defines possible elements of a document.
 #For each type of elements a class is defined.
 #The definition can be done explicite or generic with Element.create.
@@ -26,7 +77,6 @@ end
 #But the error is done, when the element is created.
 #When you redefine ELEMENTS_TRACE, some tracing information are stored during creation.
 class Element
-	include Backlinks
 	#Hash with all ids and their corresponding classes.
 	@@ids = Hash.new( )
 	#All attributes are stored in this hash.
@@ -67,13 +117,15 @@ class Element
 	end
 	#Add a new element class or assign another name (synonym) for a class.
 	#The initial call is made by Element.inherited.
+  #
+	#Element.add( [:element],  Element )
 	def  Element.add( idlist, elementClass )
 		if ! elementClass.new.kind_of?( Element )
 			raise "Element.add get no Element-class #{elementClass}"
 		end
-		if ! idlist.kind_of?( Array )
-			idlist = [ idlist ]
-		end
+    idlist = [ idlist ] if ! idlist.kind_of?( Array )
+    raise "Empty idlist for #{elementClass}" if idlist.empty?
+    
 		idlist.each{|id|
 			if @@ids[ id ] == nil
 				puts "Element class '#{id}' is new: #{elementClass}" if @@log
@@ -147,10 +199,10 @@ class Element
 		return elementclass
 	end
 	#Return all id's of the class.
-	#This method is expanded in Element.add.
+	#@@ids is expanded in Element.add.
 	def ids( )
     myids = []
-    @@ids.each{|k,v| myids << k if v == self.class }
+    @@ids.each{|k,v| myids << k if v == self.class and k.class != Class }
 		return myids
 	end
 	#Prepares an overview on all Elements.
@@ -199,23 +251,28 @@ class Element
 	def Element.add_output( target, string )
 		case target
 		when :latex
-			cmd = "def to_latex()\n"
+			cmd = "def to_latex(options = {})\n"
 		when :html
-			cmd = "def to_html()\n"
+			cmd = "def to_html(options = {})\n"
 		when :text
-			cmd = "def to_text()\n"
+			cmd = "def to_text(options = {})\n"
 		when :wiki
-			cmd = "def to_wiki()\n"
+			cmd = "def to_wiki(options = {})\n"
 		else
 			puts "#{self}: Undefined target format #{target}"
 		end
 		if ! string.kind_of?( String )
 			puts "Error element <#{self.new.ids}>: #{string.inspect} is no String"
 		end
+    cmd << <<code
+    o = Docgenerator_logger.set_option_defaults(options)
+    o[:log].debug("enter to_doc for #{self.inspect}") if o[:log].debug?
+code
 		template = string.gsub(/\\/, '\\\\\\')
 		template.gsub!(/"/, '\"')
-		cmd += "\"#{template}\"\n"
-		cmd += "end\n"
+		template.gsub!(/@content\}/, "@content.to_doc(#{target.inspect}, options)}")
+		cmd << "    \"#{template}\"\n"
+		cmd << "end\n"
 		class_eval( cmd )
 	end
 	#Defines an element.
@@ -230,13 +287,14 @@ class Element
 	def initialize( attr={}, content = nil)
 		#@attr is a hash containing the values for each attribute.
 		@attr = Hash.new(  )
+    @log  = DOCGENERATOR_LOGGER
+    #attr alias
+		@attr_alias = Hash.new(  )
     if self.content?()
       @content	= []
     else
       @content	= nil
     end
-		@part_of	= []	#list of elements, where this element is part of (normaly only one element)
-		@part_of_doc	= []	#list of documents, where this element is part of (normaly only one element)
 		@crbefore	= false	#make \n before element
 		@crmid	= false	#make \n before and after opening/closing html-tag
 		@crafter	= false	#make \n after element
@@ -262,7 +320,7 @@ class Element
 		@@attr[self.class].each{ |k,a|
 			next if !a.kind_of?( Symbol )
 			if @attr[a]
-				@attr[k] = @attr[a]
+				@attr_alias[k] = @attr[a]
 			else
 				puts "Undefined Alias-Attribute #{k}"
 				@attr[k] = Attribute.create().new( k, self )
@@ -271,6 +329,8 @@ class Element
 		attr.each{ |k,v|
 			if @attr[k]
 				@attr[k] << v
+			elsif @attr_alias[k]
+				@attr_alias[k] << v
 			else
 				puts "Usage of unknown attribute '#{k}' in '#{self.ids.join(',')}'"
 			end
@@ -285,11 +345,11 @@ class Element
 	def restrict_to( *argv )
 		@targets = []
 		@suppressed_targets = SUPPORTED_TARGETS.dup
-		puts "Element#restrict_to: #{self.inspect} restrict to #{argv.inspect}" if @@log
+		@log.warn("Element#restrict_to: #{self.inspect} restrict to #{argv.inspect}") if @log.warn?
 		argv.each{ |arg|
 			#~ if ! SUPPORTED_TARGETS.include?( arg )
 			if ! @suppressed_targets.delete( arg )
-				puts "Restriction for unsupported target #{arg}" if @@log
+				@log.warn("Restriction for unsupported target #{arg}") if @log.warn?
 			end
       @targets	<< arg
 		}
@@ -332,10 +392,8 @@ class Element
 		if @content
 			@content << content
 		else
-			puts "Add content to an element without this feature (#{self.ids}, #{content.inspect}"
-			#~ @site.add2log( :error, "Add content to an element without this feature (#{self.ids}, #{content.inspect}" )
+			@log.warn("Add content to an element without this feature #{self.ids.inspect}, #{content.inspect}") if @log.warn?
 		end
-		set_backlink( content )
 	end
 
 	#Add content after a target (other content)
@@ -406,6 +464,8 @@ class Element
 	#Return an attribute to add content.
 	def [] (key)
 		attr = @attr[key]
+    #If Attribute does not exist, take a look, if it is an alias-name.
+		attr = @attr_alias[key] if !attr
 		if !attr
 			puts "Request unknown attribute '#{key}', return a dummy"
 			attr = Attribute.create( ).new(key, self)
@@ -428,53 +488,56 @@ class Element
 	@@level = 0
 	#Build a String to be used for the target document.
 	#Calls Element#to_latex and Element#to_html.
-	def to_s( target = Document.target( self ) )
+	#~ def to_s( target = Document.target( self ) )
+	def to_doc( target, options = {} )
+    o = Docgenerator_logger.set_option_defaults(options)
+    o[:log].debug("enter to_doc for #{self.inspect}") if o[:log].debug?
 		#Return empty string, if target is not requested.
 		if ! @targets.include?( target )
       if @suppressed_targets.include?(target)
-			puts "Element#to_s: Content of #{self.inspect} suppressed for Target #{target.inspect}." if @@log
+			o[:log].info("Element#to_doc: Content of #{self.inspect} suppressed for Target #{target.inspect}.") if o[:log].info?
       else
-			puts "Element#to_s: Target #{target.inspect} not supported for #{self.inspect}." if @@log
+			o[:log].warn("Element#to_doc: Target #{target.inspect} not supported for #{self.inspect}.") if o[:log].warn?
       end
 			return ''
 		end
 		#Some checks
 		@attr.each{|k,v|
 			if v.required? and v.to_s == '' and v.settings.include?(target)
-				puts "#{self.ids}: Attribut '#{k}' without required value"
+				o[:log].error "#{self.ids}: Attribut '#{k}' without required value" if o[:log].error?
 			end
 		}
 		#Build the string.
 		result = ''
 		case target
 		when :latex
-			result = to_latex()	
+			result = to_latex(options)	
 		when :html
-			result = to_html()
+			result = to_html(options)
 		when :wiki
-			result = to_wiki()
+			result = to_wiki(options)
 		when :text
-			result = to_text()
+			result = to_text(options)
 		when :debug
 			@@level += 1
 			result = "\n<element #{self.ids.join(',')} begin>"
 			@attr.each{|k,v|
 				#result += "\n\t#{k}: #{v.inspect}" 
 				if v != []
-					result += "\n\t#{k}:" 
+					result << "\n\t#{k}:" 
 					v.each{|v2|
-						result += v2.to_s
+						result << v2.to_s
 					}
 				end
 			}
-			result += @content.to_s
-			result += "\n<element #{self.ids.join(',')} end>"
+			result << @content.to_s
+			result << "\n<element #{self.ids.join(',')} end>"
 			@@level -= 1
 			result.gsub!(/^/, "\t" * @@level ) 
 		else
-			puts "Undefined target format '#{target}'"
+			o[:log].fatal("Undefined target format '#{target}'") if o[:log].fatal?
 		end
-		#Already added in submethods
+    #Already added in submethods
 		#~ result = "\n#{result}" 	if @crbefore
 		#~ result << "\n" 			if @crafter
 		return result
@@ -483,11 +546,16 @@ class Element
 	#This method must be overwritten from the element class.
 	#
 	#By default, the concatenation of all ids and the content is taken.
-	def to_latex()
-		puts "Missing output routine for LaTeX (#{self.ids.join(',')}) [#{@called_by}]" if @@log
+	def to_latex(options = {})
+    o = Docgenerator_logger.set_option_defaults(options)
+		o[:log].error("Missing output routine for LaTeX (#{self.ids.join(',')}) [#{@called_by}]") if o[:log].error?
+    makroname = 'dummy'
+    self.ids.each{|id|
+      makroname = id if id.is_a?(Symbol) or id.is_a?(String)
+    }
 		cmd	=	''
 		cmd	<<	"\n" if @crbefore
-		cmd	<<	"\\#{self.ids}{#{@content}}"
+		cmd	<<	"\\#{makroname}{#{@content}}"
 		cmd	<<	"\n" if @crafter
 		return cmd
 	end
@@ -518,21 +586,22 @@ class Element
 	#The tag from Element.htmltag is taken and all attributes and the content are used.
 	#
 	#This method can be overwriten from the element class.
-	def to_html()
+	def to_html(options = {})
+    o = Docgenerator_logger.set_option_defaults(options)
 		tag = htmltag()
 		if ! tag 
-			puts "No HTML element available (#{self.ids.join(',')})" if @@log
+      o[:log].error("No HTML element available (#{self.ids.join(',')})") if o[:log].error?
 			return ''
 		elsif tag == ''
 			tag = 'span' 
-			puts "Missing output routine for HTML (#{self.ids.join(',')}) [#{@called_by}]" if @@log
+			o[:log].error("Missing output routine for HTML (#{self.ids.join(',')}) [#{@called_by}]") if o[:log].error?
 		end
 		#Test if the HTML-Tag should contain something, but there is nothing.
 		#If :empty_ok it is ok, that there is no content (e.g <td>)
 		#May make problems, if an empty tag is used to set a id-mark.
 		if content?() and content? != :empty_ok and
 			( ! @content or @content == [] or @content == [nil] )
-			puts "HTML-Tag #{tag} without content -> ignored"	if @@log
+			o[:log].warn("HTML-Tag #{tag} without content -> ignored")	if o[:log].warn?
 			return ''
 		end
 		html	= String.new()
@@ -544,7 +613,7 @@ class Element
 		if @content
 			html << ">"
 			html	<<"\n" if @crmid
-			html << "#{@content}"
+			html << "#{@content.to_html(options = {})}"
 			html	<< "\n" if @crmid and @content.size > 0 and html[-1,1] != "\n"
 			html << "</#{tag}>"
 		elsif	content?() == nil
@@ -555,16 +624,21 @@ class Element
 		html	<<	"\n" if @crafter
 		return html
 	end	#to_html
-	def to_wiki()
-		puts "Missing output routine for Wiki (#{self.ids.join(',')}) [#{@called_by}]" if @@log
-		return "#{@content}\n"
-	end
-	def to_text()
-		puts "Missing output routine for Text (#{self.ids.join(',')}) [#{@called_by}]" if @@log
+	def to_wiki(options = {})
+    o = Docgenerator_logger.set_option_defaults(options)
+		o[:log].error("Missing output routine for Wiki (#{self.ids.join(',')}) [#{@called_by}]") if o[:log].error?
+		return "#{@content.to_wiki(options)}\n"
+	end
+	def to_text(options = {})
+    o = Docgenerator_logger.set_option_defaults(options)
+		o[:log].error("Missing output routine for Text (#{self.ids.join(',')}) [#{@called_by}]") if o[:log].error?
 		text = String.new()
 		text	<<	"\n" if @crbefore
-		text = "#{@content}".strip
+		text = "#{@content.to_text(options)}".strip
 		text	<<	"\n" if @crafter
 		return text
 	end
-end
+  def to_s()
+    return self.inspect
+  end
+end #Element