<HTML>
<HEAD>

<TITLE>TTX Documentation</TITLE>


</HEAD>
<BODY bgcolor="#FFFFFF">

<H3>TTX -- From OpenType and TrueType to XML and Back</H3>

<A HREF="http://fonttools.sourceforge.net/">TTX</A> is a tool for manipulating TrueType and OpenType fonts. It is written in Python and has a BSD-style, open-source licence -- see LICENSE.txt. Among other things this means you can use it free of charge. It's hosted at <A HREF="http://sourceforge.net/">sourceforge.net</A>.

<P>
TTX can dump TrueType and OpenType fonts to an XML-based text format, which is also called TTX. TTX files have a .ttx file extension.

<H3>How to use TTX</H3>

The TTX application works can be used in two ways, depending on what platform you run it on:

<ul>
  <li>As a command line tool (Windows/DOS, Unix, MacOSX)</li>
  <li>By dropping files onto the application (Windows, MacOS)</li>
</ul>

<P>
TTX detects what kind of files it is fed: it will output a .ttx file when it sees a .ttf or .otf, and it will compile a .ttf or .otf when the input file is a .ttx file. By default, the output file is created in the same folder as the input file, and will have the same name as the input file but with a different extension. TTX will <I>never</I> overwrite existing files, but if necessary will append a unique number to the output filename (before the extension), eg.: "Arial#1.ttf".

<P>
When using TTX from the command line there are a bunch of extra options, these are explained in the help text, as displayed when typing "ttx -h" at the command prompt. These additional options include:
<ul>
  <li>specifying the folder where the output files are created</li>
  <li>specifying which tables to dump or which tables to exclude</li>
  <li>merging partial .ttx files with existing .ttf or .otf files</li>
  <li>listing brief table info isntead of dumping to .ttx</li>
  <li>splitting tables to separate .ttx files</li>
  <li>disabling TT instruction disassembly</li>
</ul>

<H3>The TTX file format</H3>

The following tables are currently supported:
<BLOCKQUOTE><TT>
<!-- begin table list -->
BASE, CBDT, CBLC, CFF, COLR, CPAL, DSIG, EBDT, EBLC, FFTM, GDEF, GMAP, GPKG, GPOS, GSUB, JSTF, LTSH, META, OS/2, SING, SVG, TSI0, TSI1, TSI2, TSI3, TSI5, TSIB, TSID, TSIJ, TSIP, TSIS, TSIV, VORG, cmap, cvt, fpgm, gasp, glyf, hdmx, head, hhea, hmtx, kern, loca, maxp, name, post, prep, sbix, vhea and vmtx
<!-- end table list -->
</TT></BLOCKQUOTE>
Other tables are dumped as hexadecimal data.

<P>
TrueType fonts use glyph indices (GlyphID's) to refer to glyphs in most places.
While this is fine in binary form, it is really hard to work with for
humans. Therefore we use names instead.

<P>The glyph names are either extracted from the 'CFF ' table or the 'post' table,
or are derived from a Unicode 'cmap' table. In the latter case the Adobe Glyph List
is used to calculate names based on Unicode values. If all of these mthods fail,
names are invented based on GlyphID (eg. "glyph00142").

<P>It is possible that different glyphs use the same name. If this happens,
we force the names to be unique by appending "#n" to the name (n being an
integer number). The original names are being kept, so this has no influence
on a "round tripped" font.

<P>Because the order in which glyphs are stored inside the TT font is
important, we maintain an ordered list of glyph names in the font.


<H3>Development and feedback</H3>

TTX/FontTools development is ongoing, but often goes in spurts. Feature requests and bug reports are always welcome. The best place for these is currently the fonttools-discussion mailing list at SourceForge. This list is both for discussion TTX from an end-user perspective as well as TTX/FontTools development. Subscription info can be found if you follow the "Mailing Lists" link at the <A HREF="http://sourceforge.net/projects/fonttools/">SourceForge project page</A>. You can also email me directly at <A HREF="mailto:just@letterror.com">just@letterror.com</A>.

<P>
Let me take this opportunity to mention that if you have special needs (eg. custom font monipulators, dufferent table formats, etc.): I am available for contracting.

<H3>Credits</H3>

Windows setup script: Adam Twardoch
<BR>Icon: Hannes Famira

<H3>Acknowledgements</H3>

(in alphabetical order) 
Erik van Blokland, Petr van Blokland, Jelle Bosma, Vincent Connare, 
Simon Daniels, Hannes Famira, Yannis Haralambous, Greg Hitchcock, John Hudson,
Jack Jansen, Tom Kacvinsky, Antoine Leca, Werner Lemberg, Tal Leming,
Peter Lofting, Dave Opstad, Laurence Penney, Read Roberts, Guido van Rossum, Andreas Seidel, Adam Twardoch. 

<H3>Copyrights</H3>

<A HREF="http://fonttools.sourceforge.net/">FontTools/TTX</A>
<BR>1999-2003 Just van Rossum; LettError (just@letterror.com). See LICENSE.txt for the full license.
<P>
<A HREF="http://www.python.org/">Python</A>
<BR>Copyright (c) 2001-2003 Python Software Foundation. All Rights Reserved.
<BR>Copyright (c) 2000 BeOpen.com. All Rights Reserved.
<BR>Copyright (c) 1995-2001 Corporation for National Research Initiatives. All Rights Reserved.
<BR>Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam. All Rights Reserved.
<P>
<A HREF="http://www.pfdubois.com/numpy/">Numeric Python (NumPy)</A>
<BR>Copyright (c) 1996. The Regents of the University of California. All rights reserved.

</BODY>
</HTML>
