docgenerator 1.2.1 → 2.0.0

data/lib/docgenerator/packages/pdfpages.rb

@@ -0,0 +1,43 @@
+=begin rdoc
+Implement includepdf from pdfpages-package.
+
+Requires a
+  doc.head << element(:usepackage,{},'pdfpages')
+
+The usepackage command loads this script by its own.
+
+You may also use:
+  require 'docgenerator/packages/pdfpages.rb'
+  ...
+  doc.head << IncludePDF.head
+
+=end
+
+#
+module Docgenerator
+module Packages
+=begin rdoc
+Implement includepdf from pdfpages-package.
+=end
+class IncludePDF < Element
+=begin rdoc
+Return header definition for usage of the command.
+=end  
+  def self.head()
+    element(:usepackage,{},'pdfpages').cr
+  end
+  
+  add_attribute    :pages,  Attribute.create( [ :texkeyval], [ String ] )
+  add_attribute    :nup,  Attribute.create( [ :texkeyval], [ /\d+x\d+/ ] )  #multiple logical pages onto each sheet of paper. 
+  add_attribute    :landscape,  Attribute.create( [ :texkeyval], [ true, false ] )  #multiple logical pages onto each sheet of paper. 
+  add_attribute    :pagecommand,  Attribute.create( [ :texkeyval], [ String ] )  #multiple logical pages onto each sheet of paper. 
+  add_attribute    :link,  Attribute.create( [ :texkeyval], [ true, false] )
+  add_attribute    :linkname,  Attribute.create( [ :texkeyval], [ String ] )
+  add_attribute    :linktodoc,  Attribute.create( [ :texkeyval], [ true, false] )  #Lets the inserted pages be hyperlinks to the document from which they were extracted.
+  #~ add_attribute :addtotoc, Attribute.create( [ :texkeyval], [ /.+,.+,.+,.+,.+/] ),  #
+    
+  add_output( :latex,  '#{linebreak(@crbefore)}\includepdf[#{texkeyval()}]{#{@content}}#{linebreak(@crafter)}')
+    
+  end #IncludePDF
+end #module Packages
+end #module Docgenerator

data/lib/docgenerator/packages/rubycode4doc.rb

@@ -0,0 +1,227 @@
+=begin rdoc
+Little helper to make documention on ruby scripts,
+Ruby fragments are executed line by line.
+
+The source code is enriched with the results and can be shown.
+=end
+
+require 'docgenerator'
+require 'docgenerator/packages/listings'
+#~ require '../../lib/packages/docgenerator_listings'
+
+#
+module Docgenerator
+module Rubycode
+
+
+class CodeTest
+  #Catch output.
+  #
+  #Used to replace $stdout
+  class MyIO  < String
+    def write( cont )
+      self  << cont
+    end
+  end  #MyIO
+  
+  Code_line = Struct.new('Code_line', :code, :line_number,  :result, :output, :outputtab, :comment )
+  @@all  = {}
+=begin rdoc
+Get some executable ruby code and analyse it.
+If a name is given, it is stored for later reuse (see CodeTest[])
+=end
+  def initialize( name, code = '' )
+    @name = name
+    if @@all[@name]
+      raise "Double definition of CodeTest #{name.inspect}"
+    else
+      @@all[@name] = self
+    end if name
+    #Keep binding for code execution
+    @bind = binding
+    #Collection of all coding lines (elements are Code_line-struct)
+    @codelines  = []
+    code.split(/\n/).each{|c|
+      self << c
+    }
+  end
+=begin rdoc
+Add one coding line.
+-Each line is executed,
+-The result o fthe line is added to #result
+-The output is added to #output
+
+Restrictions:
+-One line, one command (only last command returns its result)
+=end
+  def << ( c )
+    #fixme: command mit Strings "#...
+    command, comment = c.chomp.split(/#/, 2 )
+    #~ if comment
+      #~ puts '--'*10 + 'comment'
+      #~ puts c.chomp
+      #~ puts command
+      #~ puts comment.inspect
+    #~ end
+    begin
+    $stdout = output = MyIO.new
+    codeline = Code_line.new( c.chomp, @codelines.size + 1, eval(c, @bind) )
+    rescue SyntaxError
+      $stdout = STDOUT
+      DOCGENERATOR_LOGGER.error("CodeTest #{@name}: Syntax Error with: '#{c}'") if DOCGENERATOR_LOGGER.error?
+      return
+    end
+    $stdout = STDOUT
+    codeline.outputtab  = []
+    if output.size > 0
+      codeline.output    = output.inspect
+      codeline.outputtab  = output.split("\n")
+    end      
+    codeline.comment  = comment
+    @codelines  << codeline
+  end
+  #Get 'plain' sourcecode
+  def sourcecode()
+    code  = []
+    @codelines.each{|codeline|
+      code << codeline.code
+    }
+    code.join("\n")
+  end
+  #Get 'plain' output
+  def output()
+    output  = []
+    @codelines.each{|codeline|
+      #~ output << codeline.output
+      output << codeline.outputtab
+    }
+    output.join("\n")
+  end
+=begin rdoc
+Get code and results  in a verbatim env.
+The comments starts after the column max. (default: longest code line + 3 )
+
+Example:
+ 1 + 1
+becomes 
+ 1 + 1   #2  
+
+fixme: define scope, from-to line
+=end
+  def code_evaluation( max = @codelines.map{|f|f.code.size}.max  + 3 )
+    evaluated_code  = []
+    @codelines.each{|codeline|
+      #Prepare coding line with result of the line if not done before
+      evaluated_line  = "%-#{max}s" %  [ codeline.code ]
+      if codeline.result or codeline.output
+        evaluated_line  << " # "
+      end
+      if codeline.result
+        evaluated_line  << '-> %-10s' % [ codeline.result ]
+      end
+      if codeline.output
+        evaluated_line  << '=> %-10s' % [ codeline.output ]
+      end
+      evaluated_code << evaluated_line
+    }
+    evaluated_code.join("\n")
+  end
+  
+  #Get code and results  in a lstlistings environment.
+  def code_evaluation_lstlisting( max = @codelines.map{|f|f.code.size}.max  + 3 )
+    element(:lstlisting,{  :numbers => 'left',
+                    :numberstyle  => '\tiny',
+                    :class => 'rubycode_with_result',
+                  }, self.code_evaluation( max) ).cR
+  end #code_evaluation()
+=begin rdoc
+Get code 
+=end
+  def code()
+    element(:lstlisting,{  :numbers => 'left',
+                    :numberstyle  => '\tiny',
+                    :class => 'rubycode',
+                  }, @codelines.map{|codeline| codeline.code}.join("\n")).cR
+  end #code_evaluation()
+=begin rdoc
+return tabular with code, result and output.
+=end
+  def code_in_tab()
+    #~ element(:verbatim,{}, @code)
+#~ puts 'tabularx mag kein verbatim'
+    #~ tabular = element(:tabularx, {  
+            #~ :columndescription => 'lXllXX', 
+            #~ :width  => '\\textwidth',
+    tabular = element(:tabular, {  
+            :columndescription => 'lp{3cm}llp{3cm}', 
+            :columns => 5, 
+            :border => 1,
+          }).Cr
+      tabular << row = element(:row).cr.hline
+      row << element(:col, {}, 'No' )
+      row << element(:col, {}, 'Code' )
+      row << element(:col, {}, 'Result' )
+      row << element(:col, {}, 'Output' )
+      row << element(:col, {}, 'Output2' )
+    @codelines.each{|c|
+      tabular << row = element(:row).cr
+      row << element(:col, {}, c.line_number )
+      if c.code.include?("\n")
+        row << element(:col, {}, element(:lstlisting,{:class => 'rubycode' }, ["\n", c.code])  ).Cr
+      else
+        row << element(:col, {}, element(:lstinline,{:class => 'rubycode' }, c.code)  )
+      end
+      row << element(:col, {}, c.result  )
+      row << element(:col, {}, c.output ? element(:verb,{ :class => 'ruby_result_string' }, c.output) : nil )
+      #~ row << element(:col, {}, c.outputtab.map{|i| [i, element(:br)]}.flatten[0..-2] )
+      row << element(:col, {}, element(:verbatim,{:class => 'ruby_result'}, c.outputtab.join("\n") ) )
+    }
+    tabular
+  end
+=begin rdoc
+Get the code fragment
+=end
+  def self.[](name)
+    @@all[name]
+  end
+=begin rdoc
+Build a Document with required head-definitions
+(usepackage...)
+=end
+  def self.mk_document( title )
+    doc = Document.new(
+      :title => title
+    )
+    doc.head  << element(:usepackage,{ }, 'listings').cr
+    doc.head  << element(:usepackage,{ }, 'color').cr
+    doc.head  << element(:lstloadlanguages,{}, 'ruby' ).cr
+    doc.head  << element(:lstset,  {
+                        :language => 'ruby',
+                        :commentstyle  => '\color{blue}',
+                      } ).cr
+    return doc
+  end
+end  #CodeTest
+end #module Rubycode
+end #module Docgenerator
+
+if $0 == __FILE__
+test = CodeTest.new('codetest', <<CODE
+a = 5
+b = a * 5
+puts b
+puts b + 3
+CODE
+)
+puts test.code_evaluation
+
+puts "\n====Add more code====\n\n"
+test << <<TEST
+3.times{|i| 
+	puts i
+}
+TEST
+
+
+puts test.code_evaluation
+end #if $0 == __FILE__

data/lib/{packages/docgenerator_scrlettr2.rb → docgenerator/packages/scrlettr2.rb}

@@ -1,12 +1,17 @@
-#
-#Definition of elements for class DocGenerator_scrlettr2.rb
-#used by for DocGenerator.rb
-#
+=begin rdoc
+Definition of elements for LaTeX class scrlettr2 (Koma-Script)
+
+* http://www.ctan.org/tex-archive/macros/latex/contrib/koma-script/
+=end
 if __FILE__ == $0
 	require 'docgenerator' 
 end
 #~ require 'date' 
 
+#
+module Docgenerator
+module Packages
+module Letter
 DocumentTemplate.new( 
 	:scrlttr2, :latex, %q|<<prefix>>
 		\documentclass[<<classoptions>>]{scrlttr2}
@@ -25,7 +30,6 @@ DocumentTemplate.new(
 
 
 class LoadLetterOption < Element
-  Element.add( [:loadletteroption],  LoadLetterOption)
 
   def to_latex( options = {} )
 		cmd	=	''
@@ -40,12 +44,8 @@ end #LoadLetterOption
 # element(:setkomavar,{:field => field}, .content).cr
 # element(:setkomavar,{:field => field, :fieldtext=>'Text'}, .content).cr
 class Setkomavar < Element
-  Element.add( [:setkomavar],  Setkomavar)
-	add_attributes( {
-			:field	=> Attribute.create( [ :latex, :required ], [Symbol], 1 ),
-			:fieldtext	=> Attribute.create( [ :latex, :required ], [String], 2 ),
-		}#.update(HTML_ATTR_ALL)
-		)
+	add_attribute :field, Attribute.create( [ :latex, :required ], [Symbol], 1 )
+  add_attribute :fieldtext, Attribute.create( [ :latex, :required ], [String], 2 )
 
   def to_latex( options = {} )
 		cmd	=	''
@@ -70,8 +70,8 @@ end #Setkomavar
 #				:opening	=> '~',
 #				:closing	=> '~',
 #			}).cr
-class Letter < Environment
-	Element.add( [:letter],  self )
+class Letter < Environments::Environment
+  
 	add_attributes( 		{
 			:address 	=> Attribute.create( [ :latex, :required ] ),
 			:date		=> Attribute.create( [ :latex ], [String] ),	#Date?
@@ -120,7 +120,13 @@ class Letter < Environment
 			return ''
 		end
 	end
-	def to_latex_environment( environment, options = {} )
+=begin rdoc
+Redefine to_latex_environment.
+
+Parameters for letters are defined via #setkomavar.
+
+=end
+	def to_latex_environment( environment, parameter = nil, options = {} )
 		cmd	=	''
 		cmd	<<	"\n" if @crbefore
 		cmd	<<	"\n\\begin{#{environment}}"
@@ -155,7 +161,7 @@ class Letter < Environment
 		return cmd
 	end
 	def to_latex( options = {} )
-		return to_latex_environment( 'letter', options )
+		return to_latex_environment( 'letter', nil, options )
 	end
 	def to_html( options = {})
 		cmd	=	element( :div ).CR
@@ -169,4 +175,7 @@ class Letter < Environment
 		#~ cmd	<<	"\n" if @crafter
 		return cmd.to_html(options)
 	end
-end
+end
+end #module Letter
+end #module Packages
+end #module Docgenerator

data/lib/docgenerator/packages/scrpage2.rb

@@ -0,0 +1,410 @@
+module Docgenerator
+module Packages
+=begin rdoc
+Support for scrpage2.sty (Koma-Script)
+
+* http://www.ctan.org/tex-archive/macros/latex/contrib/koma-script/
+=end
+module Scrpage2
+
+=begin rdoc
+Define Element :clearscrheadings
+
+Create an instance with
+  element( :clearscrheadings, [ attributes, [content]] )
+or
+  Clearscrheadings.new( [ attributes, [content]] )
+Attributes are not defined for this element.
+=end
+class Clearscrheadings < Element
+  has_no_content false
+  add_latex_output '#{linebreak(@crbefore)}\clearscrheadings #{linebreak(@crafter)}'
+end #Clearscrheadings
+
+=begin rdoc
+Define Element :clearscrheadfoot
+
+Create an instance with
+  element( :clearscrheadfoot, [ attributes, [content]] )
+or
+  Clearscrheadfoot.new( [ attributes, [content]] )
+Attributes are not defined for this element.
+=end
+class Clearscrheadfoot < Element
+  has_no_content false
+  add_latex_output '#{linebreak(@crbefore)}\clearscrheadfoot #{linebreak(@crafter)}'
+end #Clearscrheadfoot
+
+=begin rdoc
+Define Element :clearscrplain
+
+Create an instance with
+  element( :clearscrplain, [ attributes, [content]] )
+or
+  Clearscrplain.new( [ attributes, [content]] )
+Attributes are not defined for this element.
+=end
+class Clearscrplain < Element
+  has_no_content false
+  add_latex_output '#{linebreak(@crbefore)}\clearscrplain #{linebreak(@crafter)}'
+end #Clearscrplain
+
+=begin rdoc
+Define Element :pagestyle
+
+Create an instance with
+  element( :pagestyle, [ attributes, [content]] )
+or
+  Pagestyle.new( [ attributes, [content]] )
+Attributes are not defined for this element.
+
+Values: scrheadings, scrplain
+
+=end
+class Pagestyle < Element
+  #fixme check content only scrheadings, scrplain
+  add_latex_output '#{linebreak(@crbefore)}\pagestyle{#{@content}}#{linebreak(@crafter)}'
+end #Pagestyle
+
+=begin rdoc
+Define Element :manualmark
+
+Create an instance with
+  element( :manualmark, [ attributes, [content]] )
+or
+  Manualmark.new( [ attributes, [content]] )
+Attributes are not defined for this element.
+=end
+class Manualmark < Element
+  has_no_content false
+  add_latex_output '#{linebreak(@crbefore)}\manualmark #{linebreak(@crafter)}'
+end #Manualmark
+
+=begin rdoc
+Define Element :automark
+
+Create an instance with
+  element( :automark, [ attributes, [content]] )
+or
+  Automark.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Automark < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\automark#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Automark
+
+=begin rdoc
+Define Element :lehead
+
+Create an instance with
+  element( :lehead, [ attributes, [content]] )
+or
+  Lehead.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Lehead < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\lehead#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Lehead
+
+=begin rdoc
+Define Element :cehead
+
+Create an instance with
+  element( :cehead, [ attributes, [content]] )
+or
+  Cehead.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Cehead < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\cehead#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Cehead
+
+=begin rdoc
+Define Element :rehead
+
+Create an instance with
+  element( :rehead, [ attributes, [content]] )
+or
+  Rehead.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Rehead < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\rehead#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Rehead
+
+=begin rdoc
+Define Element :lefoot
+
+Create an instance with
+  element( :lefoot, [ attributes, [content]] )
+or
+  Lefoot.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Lefoot < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\lefoot#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Lefoot
+
+=begin rdoc
+Define Element :cefoot
+
+Create an instance with
+  element( :cefoot, [ attributes, [content]] )
+or
+  Cefoot.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Cefoot < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\cefoot#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Cefoot
+
+=begin rdoc
+Define Element :refoot
+
+Create an instance with
+  element( :refoot, [ attributes, [content]] )
+or
+  Refoot.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Refoot < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\refoot#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Refoot
+
+=begin rdoc
+Define Element :lohead
+
+Create an instance with
+  element( :lohead, [ attributes, [content]] )
+or
+  Lohead.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Lohead < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\lohead#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Lohead
+
+=begin rdoc
+Define Element :cohead
+
+Create an instance with
+  element( :cohead, [ attributes, [content]] )
+or
+  Cohead.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Cohead < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\cohead#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Cohead
+
+=begin rdoc
+Define Element :rohead
+
+Create an instance with
+  element( :rohead, [ attributes, [content]] )
+or
+  Rohead.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Rohead < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\rohead#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Rohead
+
+
+=begin rdoc
+Define Element :lofoot
+
+Create an instance with
+  element( :lofoot, [ attributes, [content]] )
+or
+  Lofoot.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Lofoot < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\lofoot#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Lofoot
+
+=begin rdoc
+Define Element :cofoot
+
+Create an instance with
+  element( :cofoot, [ attributes, [content]] )
+or
+  Cofoot.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Cofoot < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\cofoot#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Cofoot
+
+=begin rdoc
+Define Element :rofoot
+
+Create an instance with
+  element( :rofoot, [ attributes, [content]] )
+or
+  Rofoot.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Rofoot < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\rofoot#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Rofoot
+
+=begin rdoc
+Define Element :ihead
+
+Create an instance with
+  element( :ihead, [ attributes, [content]] )
+or
+  Ihead.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Ihead < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\ihead#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Ihead
+
+=begin rdoc
+Define Element :chead
+
+Create an instance with
+  element( :chead, [ attributes, [content]] )
+or
+  Chead.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Chead < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\chead#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Chead
+
+=begin rdoc
+Define Element :ohead
+
+Create an instance with
+  element( :ohead, [ attributes, [content]] )
+or
+  Ohead.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Ohead < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\ohead#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Ohead
+
+=begin rdoc
+Define Element :ifoot
+
+Create an instance with
+  element( :ifoot, [ attributes, [content]] )
+or
+  Ifoot.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Ifoot < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\ifoot#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Ifoot
+
+=begin rdoc
+Define Element :cfoot
+
+Create an instance with
+  element( :cfoot, [ attributes, [content]] )
+or
+  Cfoot.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Cfoot < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\cfoot#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Cfoot
+
+=begin rdoc
+Define Element :ofoot
+
+Create an instance with
+  element( :ofoot, [ attributes, [content]] )
+or
+  Ofoot.new( [ attributes, [content]] )
+Attributes may be:
+* :rightmark: 
+=end
+class Ofoot < Element
+  add_attribute :rightmark, Attribute.create( [ :latex ], [ String ] )
+  add_latex_output '#{linebreak(@crbefore)}\ofoot#{texoptional(:rightmark)}{#{@content}}#{linebreak(@crafter)}'
+end #Ofoot
+
+#~ #
+#
+#~ class Captionof < Element
+	#~ #Make the key known to the complete key-list of elements.
+	#~ Element.add( [:captionof],  Captionof)
+	#~ add_attributes( HTML_ATTR_ALL ) 
+	#~ add_attributes( {
+			#~ :float_type =>	Attribute.create( [ :latex, :required ], [ 'figure', 'table' ] ),
+			#~ :lst_entry =>	Attribute.create( [ ], [ String ] ),
+		#~ } ) 
+	
+	#~ #Redefine standard output. 
+	#~ #Options are given, if an option is avalaible.
+	#~ def to_latex()
+		#~ cmd = linebreak(@crbefore)
+		#~ cmd << "\\captionof{#{@attr[:float_type]}}"
+		#~ #Empty [] would return empty entry for list of figures,
+		#~ cmd << "[#{@attr[:lst_entry]}]" if @attr[:lst_entry].content?
+		#~ cmd << "{#{@content}}"
+		#~ cmd << linebreak(@crafter)
+		#~ return cmd
+	#~ end
+	#~ def htmltag(); 'span'; end	#fixme
+	#~ def to_html()
+		#~ return ''
+	#~ end
+#~ end	#
+
+end #module Scrpage2
+end #module Packages
+end #module Docgenerator
+__END__
+pdf.head	<< element(:usepackage,{}, 'scrpage2' ).cr
+pdf.head	<< element(:usepackage,{}, 'totpages' ).cr
+
+pdf.head	<< element(:pagestyle,{}, 'scrheadings' ).cr
+pdf.head	<< element(:automark, {}, 'section').cr
+
+pdf.head	<< element(:clearscrheadings).cr
+pdf.head	<< element(:ihead, {}, '\\headmark').cr
+pdf.head	<< element(:ofoot,{},  '\\pagemark/\\ref{TotPages}').cr
+pdf.head	<< element(:ifoot,{},  '\\url{http://www.lickert.net}').cr