/*******************************************************************************
* Copyright 2011 See AUTHORS file.
*
* Licensed 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.
******************************************************************************/
package com.badlogic.gdx.tools.hiero;
import java.awt.font.GlyphVector;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Map.Entry;
/** Reads a TTF font file and provides access to kerning information.
*
* Thanks to the Apache FOP project for their inspiring work!
*
* @author Nathan Sweet */
class Kerning {
private Map values = Collections.EMPTY_MAP;
private int size = -1;
private int kerningPairCount = -1;
private float scale;
private long bytePosition;
private long headOffset = -1;
private long kernOffset = -1;
/** @param input The data for the TTF font.
* @param size The font size to use to determine kerning pixel offsets.
* @throws IOException If the font could not be read. */
public void load (InputStream input, int size) throws IOException {
this.size = size;
if (input == null) throw new IllegalArgumentException("input cannot be null.");
readTableDirectory(input);
if (headOffset == -1) throw new IOException("HEAD table not found.");
if (kernOffset == -1) {
values = Collections.EMPTY_MAP;
return;
}
values = new HashMap(256);
if (headOffset < kernOffset) {
readHEAD(input);
readKERN(input);
} else {
readKERN(input);
readHEAD(input);
}
input.close();
for (Iterator entryIter = values.entrySet().iterator(); entryIter.hasNext();) {
Entry entry = (Entry)entryIter.next();
// Scale the offset values using the font size.
List valueList = (List)entry.getValue();
for (ListIterator valueIter = valueList.listIterator(); valueIter.hasNext();) {
int value = ((Integer)valueIter.next()).intValue();
int glyphCode = value & 0xffff;
int offset = value >> 16;
offset = Math.round(offset * scale);
if (offset == 0)
valueIter.remove();
else
valueIter.set(new Integer((offset << 16) | glyphCode));
}
if (valueList.isEmpty()) {
entryIter.remove();
} else {
// Replace ArrayList with int[].
int[] valueArray = new int[valueList.size()];
int i = 0;
for (Iterator valueIter = valueList.iterator(); valueIter.hasNext(); i++)
valueArray[i] = ((Integer)valueIter.next()).intValue();
entry.setValue(valueArray);
kerningPairCount += valueArray.length;
}
}
}
/** Returns the encoded kerning value for the specified glyph. The glyph code for a Unicode codepoint can be retrieved with
* {@link GlyphVector#getGlyphCode(int)}. */
public int[] getValues (int firstGlyphCode) {
return (int[])values.get(new Integer(firstGlyphCode));
}
public int getKerning (int[] values, int otherGlyphCode) {
int low = 0;
int high = values.length - 1;
while (low <= high) {
int midIndex = (low + high) >>> 1;
int value = values[midIndex];
int foundGlyphCode = value & 0xffff;
if (foundGlyphCode < otherGlyphCode)
low = midIndex + 1;
else if (foundGlyphCode > otherGlyphCode)
high = midIndex - 1;
else
return value >> 16;
}
return 0;
}
public int getCount () {
return kerningPairCount;
}
private void readTableDirectory (InputStream input) throws IOException {
skip(input, 4);
int tableCount = readUnsignedShort(input);
skip(input, 6);
byte[] tagBytes = new byte[4];
for (int i = 0; i < tableCount; i++) {
tagBytes[0] = readByte(input);
tagBytes[1] = readByte(input);
tagBytes[2] = readByte(input);
tagBytes[3] = readByte(input);
skip(input, 4);
long offset = readUnsignedLong(input);
skip(input, 4);
String tag = new String(tagBytes, "ISO-8859-1");
if (tag.equals("head")) {
headOffset = offset;
if (kernOffset != -1) break;
} else if (tag.equals("kern")) {
kernOffset = offset;
if (headOffset != -1) break;
}
}
}
private void readHEAD (InputStream input) throws IOException {
seek(input, headOffset + 2 * 4 + 2 * 4 + 2);
int unitsPerEm = readUnsignedShort(input);
scale = (float)size / unitsPerEm;
}
private void readKERN (InputStream input) throws IOException {
seek(input, kernOffset + 2);
for (int subTableCount = readUnsignedShort(input); subTableCount > 0; subTableCount--) {
skip(input, 2 * 2);
int tupleIndex = readUnsignedShort(input);
if (!((tupleIndex & 1) != 0) || (tupleIndex & 2) != 0 || (tupleIndex & 4) != 0) return;
if (tupleIndex >> 8 != 0) continue;
int kerningCount = readUnsignedShort(input);
skip(input, 3 * 2);
while (kerningCount-- > 0) {
int firstGlyphCode = readUnsignedShort(input);
int secondGlyphCode = readUnsignedShort(input);
int offset = readShort(input);
int value = (offset << 16) | secondGlyphCode;
List firstGlyphValues = (List)values.get(new Integer(firstGlyphCode));
if (firstGlyphValues == null) {
firstGlyphValues = new ArrayList(256);
values.put(new Integer(firstGlyphCode), firstGlyphValues);
}
firstGlyphValues.add(new Integer(value));
}
}
}
private int readUnsignedByte (InputStream input) throws IOException {
bytePosition++;
int b = input.read();
if (b == -1) throw new EOFException("Unexpected end of file.");
return b;
}
private byte readByte (InputStream input) throws IOException {
return (byte)readUnsignedByte(input);
}
private int readUnsignedShort (InputStream input) throws IOException {
return (readUnsignedByte(input) << 8) + readUnsignedByte(input);
}
private short readShort (InputStream input) throws IOException {
return (short)readUnsignedShort(input);
}
private long readUnsignedLong (InputStream input) throws IOException {
long value = readUnsignedByte(input);
value = (value << 8) + readUnsignedByte(input);
value = (value << 8) + readUnsignedByte(input);
value = (value << 8) + readUnsignedByte(input);
return value;
}
private void skip (InputStream input, long skip) throws IOException {
while (skip > 0) {
long skipped = input.skip(skip);
if (skipped <= 0) break;
bytePosition += skipped;
skip -= skipped;
}
}
private void seek (InputStream input, long position) throws IOException {
skip(input, position - bytePosition);
}
}