* 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.

*/

/* $Id$ */

// CSOFF: LineLengthCheck

// CSOFF: NoWhitespaceAfterCheck

* This class supports a subset of the <code>TTX</code> file as produced by the Adobe FLEX

* SDK (AFDKO). In particular, it is used to parse a <code>TTX</code> file in order to

* extract character to glyph code mapping data, glyph definition data, glyph substitution

* data, and glyph positioning data.

*

* <code>TTX</code> files are used in FOP for testing and debugging purposes only. Such

* files are used to represent font data employed by complex script processing, and

* normally extracted directly from an opentype (or truetype) file. However, due to

* copyright restrictions, it is not possible to include most opentype (or truetype) font

* files directly in the FOP distribution. In such cases, <code>TTX</code> files are used

* to distribute a subset of the complex script advanced table information contained in

* certain font files to facilitate testing.

*

* @author Glenn Adams

*/

    /** logging instance */

    private static final Log log = LogFactory.getLog(TTXFile.class);                                                    // CSOK: ConstantNameCheck

    /** default script tag */

    private static final String DEFAULT_SCRIPT_TAG = "dflt";

    /** default language tag */

    private static final String DEFAULT_LANGUAGE_TAG = "dflt";

    /** ttxfile cache */

    private static Map<String,TTXFile> cache = new HashMap<String,TTXFile>();

    // transient parsing state

    private Locator locator;                                    // current document locator

    private Stack<String[]> elements;                           // stack of ttx elements being parsed

    private Map<String,Integer> glyphIds;                       // map of glyph names to glyph identifiers

    private List<int[]> cmapEntries;                            // list of <charCode,glyphCode> pairs

    private Vector<int[]> hmtxEntries;                          // vector of <width,lsb> pairs

    private Map<String,Integer> glyphClasses;                   // map of glyph names to glyph classes

    private Map<String,Map<String,List<String>>> scripts;       // map of script tag to Map<language-tag,List<features-id>>>

    private Map<String,List<String>> languages;                 // map of language tag to List<feature-id>

    private Map<String,Object[]> features;                      // map of feature id to Object[2] : { feature-tag, List<lookup-id> }

    private List<String> languageFeatures;                      // list of language system feature ids, where first is (possibly null) required feature id

    private List<String> featureLookups;                        // list of lookup ids for feature being constructed

    private List<Integer> coverageEntries;                      // list of entries for coverage table being constructed

    private Map<String,GlyphCoverageTable> coverages;           // map of coverage table keys to coverage tables

    private List subtableEntries;                               // list of lookup subtable entries

    private List<GlyphSubtable> subtables;                      // list of constructed subtables

    private List<Integer> alternates;                           // list of alternates in alternate set being constructed

    private List<Ligature> ligatures;                           // list of ligatures in ligature set being constructed

    private List<Integer> substitutes;                          // list of substitutes in (multiple substitution) sequence being constructed

    private List<PairValues> pairs;                             // list of pair value records being constructed

    private List<PairValues[]> pairSets;                        // list of pair value sets (as arrays) being constructed

    private List<Anchor> anchors;                               // list of anchors of base|mark|component record being constructed

    private List<Anchor[]> components;                          // list of ligature component anchors being constructed

    private List<MarkAnchor> markAnchors;                       // list of mark anchors being constructed

    private List<Anchor[]> baseOrMarkAnchors;                   // list of base|mark2 anchors being constructed

    private List<Anchor[][]> ligatureAnchors;                   // list of ligature anchors being constructed

    private List<Anchor[]> attachmentAnchors;                   // list of entry|exit attachment anchors being constructed

    private List<RuleLookup> ruleLookups;                       // list of rule lookups being constructed

    private int glyphIdMax;                                     // maximum glyph id

    private int cmPlatform;                                     // plaform id of cmap being constructed

    private int cmEncoding;                                     // plaform id of cmap being constructed

    private int cmLanguage;                                     // plaform id of cmap being constructed

    private int flIndex;                                        // index of feature being constructed

    private int flSequence;                                     // feature sequence within feature list

    private int ltIndex;                                        // index of lookup table being constructed

    private int ltSequence;                                     // lookup sequence within table

    private int ltFlags;                                        // flags of current lookup being constructed

    private int stSequence;                                     // subtable sequence number within lookup

    private int stFormat;                                       // format of current subtable being constructed

    private int ctFormat;                                       // format of coverage table being constructed

    private int ctIndex;                                        // index of coverage table being constructed

    private int rlSequence;                                     // rule lookup sequence index

    private int rlLookup;                                       // rule lookup lookup index

    private int psIndex;                                        // pair set index

    private int vf1;                                            // value format 1 (used with pair pos and single pos)

    private int vf2;                                            // value format 2 (used with pair pos)

    private int g2;                                             // glyph id 2 (used with pair pos)

    private int xCoord;                                         // x coordinate of anchor being constructed

    private int yCoord;                                         // y coordinate of anchor being constructed

    private int markClass;                                      // mark class of mark anchor being constructed

    private String defaultScriptTag;                            // tag of default script

    private String scriptTag;                                   // tag of script being constructed

    private String defaultLanguageTag;                          // tag of default language system

    private String languageTag;                                 // tag of language system being constructed

    private String featureTag;                                  // tag of feature being constructed

    private Value v1;                                           // positioining value 1

    private Value v2;                                           // positioining value 2

    // resultant state

    private int upem;                                           // units per em

    private Map<Integer,Integer> cmap;                          // constructed character map

    private Map<Integer,Integer> gmap;                          // constructed glyph map

    private int[][] hmtx;                                       // constructed horizontal metrics - array of design { width, lsb } pairs, indexed by glyph code

    private int[] widths;                                       // pdf normalized widths (millipoints)

    private GlyphDefinitionTable gdef;                          // constructed glyph definition table

    private GlyphSubstitutionTable gsub;                        // constructed glyph substitution table

    private GlyphPositioningTable gpos;                         // constructed glyph positioning table

    public TTXFile() {

        elements = new Stack<String[]>();

        glyphIds = new HashMap<String,Integer>();

        cmapEntries = new ArrayList<int[]>();

        hmtxEntries = new Vector<int[]>();

        glyphClasses = new HashMap<String,Integer>();

        scripts = new HashMap<String,Map<String,List<String>>>();

        languages = new HashMap<String,List<String>>();

        features = new HashMap<String,Object[]>();

        languageFeatures = new ArrayList<String>();

        featureLookups = new ArrayList<String>();

        coverageEntries = new ArrayList<Integer>();

        coverages = new HashMap<String,GlyphCoverageTable>();

        subtableEntries = new ArrayList();

        subtables = new ArrayList<GlyphSubtable>();

        alternates = new ArrayList<Integer>();

        ligatures = new ArrayList<Ligature>();

        substitutes = new ArrayList<Integer>();

        pairs = new ArrayList<PairValues>();

        pairSets = new ArrayList<PairValues[]>();

        anchors = new ArrayList<Anchor>();

        markAnchors = new ArrayList<MarkAnchor>();

        baseOrMarkAnchors = new ArrayList<Anchor[]>();

        ligatureAnchors = new ArrayList<Anchor[][]>();

        components = new ArrayList<Anchor[]>();

        attachmentAnchors = new ArrayList<Anchor[]>();

        ruleLookups = new ArrayList<RuleLookup>();

        glyphIdMax = -1;

        cmPlatform = -1;

        cmEncoding = -1;

        cmLanguage = -1;

        flIndex = -1;

        flSequence = 0;

        ltIndex = -1;

        ltSequence = 0;

        ltFlags = 0;

        stSequence = 0;

        stFormat = 0;

        ctFormat = -1;

        ctIndex = -1;

        rlSequence = -1;

        rlLookup = -1;

        psIndex = -1;

        vf1 = -1;

        vf2 = -1;

        g2 = -1;

        xCoord = Integer.MIN_VALUE;

        yCoord = Integer.MIN_VALUE;

        markClass = -1;

        defaultScriptTag = DEFAULT_SCRIPT_TAG;

        scriptTag = null;

        defaultLanguageTag = DEFAULT_LANGUAGE_TAG;

        languageTag = null;

        featureTag = null;

        v1 = null;

        v2 = null;

        upem = -1;

    }

    public void parse ( String filename ) {

        parse ( new File ( filename ) );

    }

    public void parse ( File f ) {

        assert f != null;

        try {

            SAXParserFactory spf = SAXParserFactory.newInstance();

            SAXParser sp = spf.newSAXParser();

            sp.parse ( f, new Handler() );

        } catch ( FactoryConfigurationError e ) {

            throw new RuntimeException ( e.getMessage() );

        } catch ( ParserConfigurationException e ) {

            throw new RuntimeException ( e.getMessage() );

        } catch ( SAXException e ) {

            throw new RuntimeException ( e.getMessage() );

        } catch ( IOException e ) {

            throw new RuntimeException ( e.getMessage() );

        }

    }

    public GlyphSequence mapCharsToGlyphs ( String s ) {

        Integer[] ca = UTF32.toUTF32 ( s, 0, true );

        int ng = ca.length;

        IntBuffer cb = IntBuffer.allocate ( ng );

        IntBuffer gb = IntBuffer.allocate ( ng );

        for ( Integer c : ca ) {

            int g = mapCharToGlyph ( (int) c );

            if ( g >= 0 ) {

                cb.put ( c );

                gb.put ( g );

            } else {

                throw new IllegalArgumentException ( "character " + CharUtilities.format ( c ) + " has no corresponding glyph" );

            }

        }

        cb.rewind();

        gb.rewind();

        return new GlyphSequence ( cb, gb, null );

    }

    public int mapCharToGlyph ( int c ) {

        if ( cmap != null ) {

            Integer g = cmap.get ( Integer.valueOf ( c ) );

            if ( g != null ) {

                return (int) g;

            } else {

                return -1;

            }

        } else {

            return -1;