 -----
 Doxia Modules Guide
 -----
 Vincent Siveton
 ------
 2009-06-15
 ------

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

Doxia Modules Guide

 Doxia has several built-in modules that support some standard markup languages,
 see the {{{../references/index.html}References}} page for an overview. The following
 is just a collection of reference links for the individual formats.

%{toc|section=1|fromDepth=2|toDepth=2}


* {APT}

 APT (Almost Plain Text) is a simple text format.

 <<References>>:

  * {{{../references/apt-format.html}Apt Reference}}

  []

* {Confluence}

 {{{http://confluence.atlassian.com}Confluence}} is an Enterprise wiki from {{{http://www.atlassian.com}Atlassian}}.
 It uses {{{http://textism.com/tools/textile/}Textile}} inside as an APT language.

 <<References>>:

  * {{{http://confluence.atlassian.com/display/CONF25/Confluence+Notation+Guide+Overview}Confluence Notation Guide Overview}}

  * {{{http://confluence.atlassian.com/renderer/notationhelp.action?section=all}Confluence Element Reference}}

  []

~~ Textile in Java {{{https://sourceforge.net/projects/jtextile/}JTextile}}.
~~ http://hobix.com/textile/

* {Simplified DocBook}

 {{{http://docbook.org/}DocBook}} is a markup language for technical documentation.
 {{{http://www.docbook.org/schemas/simplified}Simplified DocBook}} is a simpler subset.

 <<References>>:

  * {{{https://www.docbook.org/schemas/simplified}Simplified DocBook Introduction}}

  * {{{http://www.docbook.org/xml/simple/sdocbook/elements.html}Simplified DocBook Element Reference}}

  []

* {FML}

 FML (FAQ Markup Language) is a FAQ markup language.

 <<References>>:

  * {{{../references/fml-format.html}FML Reference}}

  []

* {iText}

 {{{http://www.lowagie.com/iText/}iText}} is a free Java/PDF library.

 <<References>>:

  * {{{http://itextdocs.lowagie.com/tutorial/}iText tutorial}}

~~  * {{{http://www.lowagie.com/iText/tutorial/ch07.html}(out-dated) chapter on XML support}}

  []

* {FO}

 XSL formatting objects (XSL-FO)

 <<References>>:

  * {{{https://www.w3.org/TR/xsl11/}XSL-FO Recommendation (05 December 2006)}}

  * {{{https://zvon.org/xxl/xslfoReference/Output/index.html}XSL FO reference}}

  * {{{https://xmlgraphics.apache.org/fop/}Apache FOP}}

  []

* {LaTeX}

 {{{https://www.latex-project.org/}LaTeX}} is a popular document markup language.

 <<References>>:

  * {{{https://www.latex-project.org/guides/usrguide.pdf}LaTeX2e for authors}}

  * {{{http://www.stdout.org/~winston/latex/latexsheet.pdf}Latex reference sheet}}

  []

* {Markdown}

 {{{http://en.wikipedia.org/wiki/Markdown}Markdown}} is a widespread Markup language.

 <<References>>:

  * {{{https://daringfireball.net/projects/markdown/}Official Markdown project at Daring Fireball}}

  []

* {RTF}

 {{{http://www.microsoft.com/downloads/details.aspx?FamilyId=DD422B8D-FF06-4207-B476-6B5396A18A2B&displaylang=en}RTF}}
  is a proprietary document file format.

 <<References>>:

  * {{{http://www.microsoft.com/downloads/info.aspx?na=46&p=1&SrcDisplayLang=en&SrcCategoryId=&SrcFamilyId=dd422b8d-ff06-4207-b476-6b5396a18a2b&u=http%3a%2f%2fdownload.microsoft.com%2fdownload%2f2%2ff%2f5%2f2f599e18-07ee-4ec5-a1e7-f4e6a9423592%2fWord2007RTFSpec9.doc&oRef=http%3a%2f%2fmsdn2.microsoft.com%2fen-us%2foffice%2faa905482.aspx}Microsoft Office Word 2007 Rich Text Format (RTF) Specification}}

  * {{{http://search.cpan.org/~sburke/RTF-Writer/lib/RTF/Cookbook.pod}RTF Cookbook}}

  []

* {TWiki}

 {{{https://twiki.org/}TWiki}} is a structured wiki.

 <<References>>:

  * {{{https://twiki.org/cgi-bin/view/TWiki04x01/TextFormattingRules} TWiki Text Formatting}}

  []

* {XDoc}

 XDoc is a generic format for document into a styled HTML document.

 <<References>>:

  * {{{../references/xdoc-format.html}XDoc Reference}}

  []

* {XHTML}

 {{{https://www.w3.org/MarkUp/}XHTML}} is a markup language with the same expressions as HTML, but also
 conforms to XML syntax.

 <<References>>:

  * {{{http://www.iangraham.org/books/xhtml1/extras/html-7nov2000.pdf}HTML and XHTML Quick Reference Charts: Head and Body Markup}}

  * {{{https://www.w3.org/TR/xhtml1/}XHTML 1.0 Specification}}

  []
