Datasets:

---

CM

/

codexglue_code2text_java

like 4

[ "public", "void", "setSystem", "(", "ParticleSystem", "system", ")", "{", "this", ".", "system", "=", "system", ";", "emitters", ".", "clear", "(", ")", ";", "system", ".", "setRemoveCompletedEmitters", "(", "false", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "system", ".", "getEmitterCount", "(", ")", ";", "i", "++", ")", "{", "emitters", ".", "add", "(", "system", ".", "getEmitter", "(", "i", ")", ")", ";", "}", "}" ]

[ "Set", "the", "particle", "system", "to", "be", "displayed" ]

[ "public", "CharSet", "copy", "(", ")", "{", "CharSet", "copy", "=", "new", "CharSet", "(", ")", ";", "copy", ".", "name", "=", "name", ";", "copy", ".", "source", "=", "source", ";", "copy", ".", "mutable", "=", "true", ";", "copy", ".", "chars", "=", "new", "boolean", "[", "256", "]", ";", "System", ".", "arraycopy", "(", "chars", ",", "0", ",", "copy", ".", "chars", ",", "0", ",", "chars", ".", "length", ")", ";", "return", "copy", ";", "}" ]

[ "Copy", "this", "character", "set" ]

[ "public", "void", "save", "(", "File", "file", ")", "throws", "IOException", "{", "DataOutputStream", "dout", "=", "new", "DataOutputStream", "(", "new", "FileOutputStream", "(", "file", ")", ")", ";", "dout", ".", "writeUTF", "(", "name", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "256", ";", "i", "++", ")", "{", "dout", ".", "writeBoolean", "(", "chars", "[", "i", "]", ")", ";", "}", "dout", ".", "close", "(", ")", ";", "}" ]

[ "Save", "the", "set", "to", "a", "file" ]

[ "public", "void", "lineTo", "(", "float", "x", ",", "float", "y", ")", "{", "if", "(", "hole", "!=", "null", ")", "{", "hole", ".", "add", "(", "new", "float", "[", "]", "{", "x", ",", "y", "}", ")", ";", "}", "else", "{", "localPoints", ".", "add", "(", "new", "float", "[", "]", "{", "x", ",", "y", "}", ")", ";", "}", "cx", "=", "x", ";", "cy", "=", "y", ";", "pointsDirty", "=", "true", ";", "}" ]

[ "Add", "a", "line", "to", "the", "contour", "or", "hole", "which", "ends", "at", "the", "specified", "location", "." ]

[ "private", "ArrayList", "transform", "(", "ArrayList", "pts", ",", "Transform", "t", ")", "{", "float", "[", "]", "in", "=", "new", "float", "[", "pts", ".", "size", "(", ")", "*", "2", "]", ";", "float", "[", "]", "out", "=", "new", "float", "[", "pts", ".", "size", "(", ")", "*", "2", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "pts", ".", "size", "(", ")", ";", "i", "++", ")", "{", "in", "[", "i", "*", "2", "]", "=", "(", "(", "float", "[", "]", ")", "pts", ".", "get", "(", "i", ")", ")", "[", "0", "]", ";", "in", "[", "(", "i", "*", "2", ")", "+", "1", "]", "=", "(", "(", "float", "[", "]", ")", "pts", ".", "get", "(", "i", ")", ")", "[", "1", "]", ";", "}", "t", ".", "transform", "(", "in", ",", "0", ",", "out", ",", "0", ",", "pts", ".", "size", "(", ")", ")", ";", "ArrayList", "outList", "=", "new", "ArrayList", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "pts", ".", "size", "(", ")", ";", "i", "++", ")", "{", "outList", ".", "add", "(", "new", "float", "[", "]", "{", "out", "[", "(", "i", "*", "2", ")", "]", ",", "out", "[", "(", "i", "*", "2", ")", "+", "1", "]", "}", ")", ";", "}", "return", "outList", ";", "}" ]

[ "Transform", "a", "list", "of", "points" ]

[ "private", "String", "morphColor", "(", "String", "str", ")", "{", "if", "(", "str", ".", "equals", "(", "\"\"", ")", ")", "{", "return", "\"#000000\"", ";", "}", "if", "(", "str", ".", "equals", "(", "\"white\"", ")", ")", "{", "return", "\"#ffffff\"", ";", "}", "if", "(", "str", ".", "equals", "(", "\"black\"", ")", ")", "{", "return", "\"#000000\"", ";", "}", "return", "str", ";", "}" ]

[ "Morph", "the", "color", "from", "a", "string" ]

[ "public", "void", "addAttribute", "(", "String", "attribute", ",", "String", "value", ")", "{", "if", "(", "value", "==", "null", ")", "{", "value", "=", "\"\"", ";", "}", "if", "(", "attribute", ".", "equals", "(", "FILL", ")", ")", "{", "value", "=", "morphColor", "(", "value", ")", ";", "}", "if", "(", "attribute", ".", "equals", "(", "STROKE_OPACITY", ")", ")", "{", "if", "(", "value", ".", "equals", "(", "\"0\"", ")", ")", "{", "props", ".", "setProperty", "(", "STROKE", ",", "\"none\"", ")", ";", "}", "}", "if", "(", "attribute", ".", "equals", "(", "STROKE_WIDTH", ")", ")", "{", "if", "(", "value", ".", "equals", "(", "\"\"", ")", ")", "{", "value", "=", "\"1\"", ";", "}", "if", "(", "value", ".", "endsWith", "(", "\"px\"", ")", ")", "{", "value", "=", "value", ".", "substring", "(", "0", ",", "value", ".", "length", "(", ")", "-", "2", ")", ";", "}", "}", "if", "(", "attribute", ".", "equals", "(", "STROKE", ")", ")", "{", "if", "(", "\"none\"", ".", "equals", "(", "props", ".", "getProperty", "(", "STROKE", ")", ")", ")", "{", "return", ";", "}", "if", "(", "\"\"", ".", "equals", "(", "props", ".", "getProperty", "(", "STROKE", ")", ")", ")", "{", "return", ";", "}", "value", "=", "morphColor", "(", "value", ")", ";", "}", "props", ".", "setProperty", "(", "attribute", ",", "value", ")", ";", "}" ]

[ "Add", "a", "configured", "style", "attribute", "into", "the", "data", "set" ]

[ "public", "Color", "getAsColor", "(", "String", "attribute", ")", "{", "if", "(", "!", "isColor", "(", "attribute", ")", ")", "{", "throw", "new", "RuntimeException", "(", "\"Attribute \"", "+", "attribute", "+", "\" is not specified as a color:\"", "+", "getAttribute", "(", "attribute", ")", ")", ";", "}", "int", "col", "=", "Integer", ".", "parseInt", "(", "getAttribute", "(", "attribute", ")", ".", "substring", "(", "1", ")", ",", "16", ")", ";", "return", "new", "Color", "(", "col", ")", ";", "}" ]

[ "Get", "an", "attribute", "value", "converted", "to", "a", "color", ".", "isColor", "should", "first", "be", "checked" ]

[ "public", "float", "getAsFloat", "(", "String", "attribute", ")", "{", "String", "value", "=", "getAttribute", "(", "attribute", ")", ";", "if", "(", "value", "==", "null", ")", "{", "return", "0", ";", "}", "try", "{", "return", "Float", ".", "parseFloat", "(", "value", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "\"Attribute \"", "+", "attribute", "+", "\" is not specified as a float:\"", "+", "getAttribute", "(", "attribute", ")", ")", ";", "}", "}" ]

[ "Get", "an", "attribute", "converted", "to", "a", "float", "value" ]

[ "public", "int", "loadGlyphs", "(", "List", "glyphs", ",", "int", "maxGlyphsToLoad", ")", "throws", "SlickException", "{", "if", "(", "rowHeight", "!=", "0", "&&", "maxGlyphsToLoad", "==", "-", "1", ")", "{", "// If this page has glyphs and we are not loading incrementally, return zero if any of the glyphs don't fit.\r", "int", "testX", "=", "pageX", ";", "int", "testY", "=", "pageY", ";", "int", "testRowHeight", "=", "rowHeight", ";", "for", "(", "Iterator", "iter", "=", "getIterator", "(", "glyphs", ")", ";", "iter", ".", "hasNext", "(", ")", ";", ")", "{", "Glyph", "glyph", "=", "(", "Glyph", ")", "iter", ".", "next", "(", ")", ";", "int", "width", "=", "glyph", ".", "getWidth", "(", ")", ";", "int", "height", "=", "glyph", ".", "getHeight", "(", ")", ";", "if", "(", "testX", "+", "width", ">=", "pageWidth", ")", "{", "testX", "=", "0", ";", "testY", "+=", "testRowHeight", ";", "testRowHeight", "=", "height", ";", "}", "else", "if", "(", "height", ">", "testRowHeight", ")", "{", "testRowHeight", "=", "height", ";", "}", "if", "(", "testY", "+", "testRowHeight", ">=", "pageWidth", ")", "return", "0", ";", "testX", "+=", "width", ";", "}", "}", "Color", ".", "white", ".", "bind", "(", ")", ";", "pageImage", ".", "bind", "(", ")", ";", "int", "i", "=", "0", ";", "for", "(", "Iterator", "iter", "=", "getIterator", "(", "glyphs", ")", ";", "iter", ".", "hasNext", "(", ")", ";", ")", "{", "Glyph", "glyph", "=", "(", "Glyph", ")", "iter", ".", "next", "(", ")", ";", "int", "width", "=", "Math", ".", "min", "(", "MAX_GLYPH_SIZE", ",", "glyph", ".", "getWidth", "(", ")", ")", ";", "int", "height", "=", "Math", ".", "min", "(", "MAX_GLYPH_SIZE", ",", "glyph", ".", "getHeight", "(", ")", ")", ";", "if", "(", "rowHeight", "==", "0", ")", "{", "// The first glyph always fits.\r", "rowHeight", "=", "height", ";", "}", "else", "{", "// Wrap to the next line if needed, or break if no more fit.\r", "if", "(", "pageX", "+", "width", ">=", "pageWidth", ")", "{", "if", "(", "pageY", "+", "rowHeight", "+", "height", ">=", "pageHeight", ")", "break", ";", "pageX", "=", "0", ";", "pageY", "+=", "rowHeight", ";", "rowHeight", "=", "height", ";", "}", "else", "if", "(", "height", ">", "rowHeight", ")", "{", "if", "(", "pageY", "+", "height", ">=", "pageHeight", ")", "break", ";", "rowHeight", "=", "height", ";", "}", "}", "renderGlyph", "(", "glyph", ",", "width", ",", "height", ")", ";", "pageGlyphs", ".", "add", "(", "glyph", ")", ";", "pageX", "+=", "width", ";", "iter", ".", "remove", "(", ")", ";", "i", "++", ";", "if", "(", "i", "==", "maxGlyphsToLoad", ")", "{", "// If loading incrementally, flip orderAscending so it won't change, since we'll probably load the rest next time.\r", "orderAscending", "=", "!", "orderAscending", ";", "break", ";", "}", "}", "TextureImpl", ".", "bindNone", "(", ")", ";", "// Every other batch of glyphs added to a page are sorted the opposite way to attempt to keep same size glyps together.\r", "orderAscending", "=", "!", "orderAscending", ";", "return", "i", ";", "}" ]

[ "Loads", "glyphs", "to", "the", "backing", "texture", "and", "sets", "the", "image", "on", "each", "loaded", "glyph", ".", "Loaded", "glyphs", "are", "removed", "from", "the", "list", "." ]

[ "private", "void", "renderGlyph", "(", "Glyph", "glyph", ",", "int", "width", ",", "int", "height", ")", "throws", "SlickException", "{", "// Draw the glyph to the scratch image using Java2D.\r", "scratchGraphics", ".", "setComposite", "(", "AlphaComposite", ".", "Clear", ")", ";", "scratchGraphics", ".", "fillRect", "(", "0", ",", "0", ",", "MAX_GLYPH_SIZE", ",", "MAX_GLYPH_SIZE", ")", ";", "scratchGraphics", ".", "setComposite", "(", "AlphaComposite", ".", "SrcOver", ")", ";", "scratchGraphics", ".", "setColor", "(", "java", ".", "awt", ".", "Color", ".", "white", ")", ";", "for", "(", "Iterator", "iter", "=", "unicodeFont", ".", "getEffects", "(", ")", ".", "iterator", "(", ")", ";", "iter", ".", "hasNext", "(", ")", ";", ")", "", "(", "(", "Effect", ")", "iter", ".", "next", "(", ")", ")", ".", "draw", "(", "scratchImage", ",", "scratchGraphics", ",", "unicodeFont", ",", "glyph", ")", ";", "glyph", ".", "setShape", "(", "null", ")", ";", "// The shape will never be needed again.\r", "WritableRaster", "raster", "=", "scratchImage", ".", "getRaster", "(", ")", ";", "int", "[", "]", "row", "=", "new", "int", "[", "width", "]", ";", "for", "(", "int", "y", "=", "0", ";", "y", "<", "height", ";", "y", "++", ")", "{", "raster", ".", "getDataElements", "(", "0", ",", "y", ",", "width", ",", "1", ",", "row", ")", ";", "scratchIntBuffer", ".", "put", "(", "row", ")", ";", "}", "GL", ".", "glTexSubImage2D", "(", "SGL", ".", "GL_TEXTURE_2D", ",", "0", ",", "pageX", ",", "pageY", ",", "width", ",", "height", ",", "SGL", ".", "GL_BGRA", ",", "SGL", ".", "GL_UNSIGNED_BYTE", ",", "scratchByteBuffer", ")", ";", "scratchIntBuffer", ".", "clear", "(", ")", ";", "glyph", ".", "setImage", "(", "pageImage", ".", "getSubImage", "(", "pageX", ",", "pageY", ",", "width", ",", "height", ")", ")", ";", "}" ]

[ "Loads", "a", "single", "glyph", "to", "the", "backing", "texture", "if", "it", "fits", "." ]

[ "private", "Iterator", "getIterator", "(", "List", "glyphs", ")", "{", "if", "(", "orderAscending", ")", "return", "glyphs", ".", "iterator", "(", ")", ";", "final", "ListIterator", "iter", "=", "glyphs", ".", "listIterator", "(", "glyphs", ".", "size", "(", ")", ")", ";", "return", "new", "Iterator", "(", ")", "{", "public", "boolean", "hasNext", "(", ")", "{", "return", "iter", ".", "hasPrevious", "(", ")", ";", "}", "public", "Object", "next", "(", ")", "{", "return", "iter", ".", "previous", "(", ")", ";", "}", "public", "void", "remove", "(", ")", "{", "iter", ".", "remove", "(", ")", ";", "}", "}", ";", "}" ]

[ "Returns", "an", "iterator", "for", "the", "specified", "glyphs", "sorted", "either", "ascending", "or", "descending", "." ]

[ "boolean", "seekTab", "(", "FontFileReader", "in", ",", "String", "name", ",", "long", "offset", ")", "throws", "IOException", "{", "TTFDirTabEntry", "dt", "=", "(", "TTFDirTabEntry", ")", "dirTabs", ".", "get", "(", "name", ")", ";", "if", "(", "dt", "==", "null", ")", "{", "log", ".", "error", "(", "\"Dirtab \"", "+", "name", "+", "\" not found.\"", ")", ";", "return", "false", ";", "}", "else", "{", "in", ".", "seekSet", "(", "dt", ".", "getOffset", "(", ")", "+", "offset", ")", ";", "this", ".", "currentDirTab", "=", "dt", ";", "}", "return", "true", ";", "}" ]

[ "Position", "inputstream", "to", "position", "indicated", "in", "the", "dirtab", "offset", "+", "offset" ]

[ "private", "void", "createCMaps", "(", ")", "{", "cmaps", "=", "new", "java", ".", "util", ".", "ArrayList", "(", ")", ";", "TTFCmapEntry", "tce", "=", "new", "TTFCmapEntry", "(", ")", ";", "Iterator", "e", "=", "unicodeMapping", ".", "listIterator", "(", ")", ";", "UnicodeMapping", "um", "=", "(", "UnicodeMapping", ")", "e", ".", "next", "(", ")", ";", "UnicodeMapping", "lastMapping", "=", "um", ";", "tce", ".", "setUnicodeStart", "(", "um", ".", "getUnicodeIndex", "(", ")", ")", ";", "tce", ".", "setGlyphStartIndex", "(", "um", ".", "getGlyphIndex", "(", ")", ")", ";", "while", "(", "e", ".", "hasNext", "(", ")", ")", "{", "um", "=", "(", "UnicodeMapping", ")", "e", ".", "next", "(", ")", ";", "if", "(", "(", "(", "lastMapping", ".", "getUnicodeIndex", "(", ")", "+", "1", ")", "!=", "um", ".", "getUnicodeIndex", "(", ")", ")", "||", "(", "(", "lastMapping", ".", "getGlyphIndex", "(", ")", "+", "1", ")", "!=", "um", ".", "getGlyphIndex", "(", ")", ")", ")", "{", "tce", ".", "setUnicodeEnd", "(", "lastMapping", ".", "getUnicodeIndex", "(", ")", ")", ";", "cmaps", ".", "add", "(", "tce", ")", ";", "tce", "=", "new", "TTFCmapEntry", "(", ")", ";", "tce", ".", "setUnicodeStart", "(", "um", ".", "getUnicodeIndex", "(", ")", ")", ";", "tce", ".", "setGlyphStartIndex", "(", "um", ".", "getGlyphIndex", "(", ")", ")", ";", "}", "lastMapping", "=", "um", ";", "}", "tce", ".", "setUnicodeEnd", "(", "um", ".", "getUnicodeIndex", "(", ")", ")", ";", "cmaps", ".", "add", "(", "tce", ")", ";", "}" ]

[ "Create", "teh", "CMAPS", "table" ]

[ "public", "int", "getFlags", "(", ")", "{", "int", "flags", "=", "32", ";", "// Use Adobe Standard charset", "if", "(", "italicAngle", "!=", "0", ")", "{", "flags", "=", "flags", "|", "64", ";", "}", "if", "(", "isFixedPitch", "!=", "0", ")", "{", "flags", "=", "flags", "|", "2", ";", "}", "if", "(", "hasSerifs", ")", "{", "flags", "=", "flags", "|", "1", ";", "}", "return", "flags", ";", "}" ]

[ "Returns", "the", "Flags", "attribute", "of", "the", "font", "." ]

[ "public", "int", "[", "]", "getFontBBox", "(", ")", "{", "final", "int", "[", "]", "fbb", "=", "new", "int", "[", "4", "]", ";", "fbb", "[", "0", "]", "=", "fontBBox1", ";", "fbb", "[", "1", "]", "=", "fontBBox2", ";", "fbb", "[", "2", "]", "=", "fontBBox3", ";", "fbb", "[", "3", "]", "=", "fontBBox4", ";", "return", "fbb", ";", "}" ]

[ "Returns", "the", "font", "bounding", "box", "." ]

[ "public", "int", "[", "]", "getWidths", "(", ")", "{", "int", "[", "]", "wx", "=", "new", "int", "[", "mtxTab", ".", "length", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "wx", ".", "length", ";", "i", "++", ")", "{", "wx", "[", "i", "]", "=", "(", "mtxTab", "[", "i", "]", ".", "getWx", "(", ")", ")", ";", "}", "return", "wx", ";", "}" ]

[ "Returns", "an", "array", "of", "character", "widths", "." ]

[ "protected", "void", "readHorizontalHeader", "(", "FontFileReader", "in", ")", "throws", "IOException", "{", "seekTab", "(", "in", ",", "\"hhea\"", ",", "4", ")", ";", "hheaAscender", "=", "in", ".", "readTTFShort", "(", ")", ";", "log", ".", "debug", "(", "\"hhea.Ascender: \"", "+", "hheaAscender", "+", "\" \"", "+", "(", "hheaAscender", ")", ")", ";", "hheaDescender", "=", "in", ".", "readTTFShort", "(", ")", ";", "log", ".", "debug", "(", "\"hhea.Descender: \"", "+", "hheaDescender", "+", "\" \"", "+", "(", "hheaDescender", ")", ")", ";", "in", ".", "skip", "(", "2", "+", "2", "+", "3", "*", "2", "+", "8", "*", "2", ")", ";", "nhmtx", "=", "in", ".", "readTTFUShort", "(", ")", ";", "log", ".", "debug", "(", "\"Number of horizontal metrics: \"", "+", "nhmtx", ")", ";", "}" ]

[ "Read", "the", "hhea", "table", "to", "find", "the", "ascender", "and", "descender", "and", "size", "of", "hmtx", "table", "as", "a", "fixed", "size", "font", "might", "have", "only", "one", "width", "." ]

[ "private", "final", "void", "readPostScript", "(", "FontFileReader", "in", ")", "throws", "IOException", "{", "seekTab", "(", "in", ",", "\"post\"", ",", "0", ")", ";", "postFormat", "=", "in", ".", "readTTFLong", "(", ")", ";", "italicAngle", "=", "in", ".", "readTTFULong", "(", ")", ";", "underlinePosition", "=", "in", ".", "readTTFShort", "(", ")", ";", "underlineThickness", "=", "in", ".", "readTTFShort", "(", ")", ";", "isFixedPitch", "=", "in", ".", "readTTFULong", "(", ")", ";", "//Skip memory usage values", "in", ".", "skip", "(", "4", "*", "4", ")", ";", "log", ".", "debug", "(", "\"PostScript format: 0x\"", "+", "Integer", ".", "toHexString", "(", "postFormat", ")", ")", ";", "switch", "(", "postFormat", ")", "{", "case", "0x00010000", ":", "log", ".", "debug", "(", "\"PostScript format 1\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "Glyphs", ".", "MAC_GLYPH_NAMES", ".", "length", ";", "i", "++", ")", "{", "mtxTab", "[", "i", "]", ".", "setName", "(", "Glyphs", ".", "MAC_GLYPH_NAMES", "[", "i", "]", ")", ";", "}", "break", ";", "case", "0x00020000", ":", "log", ".", "debug", "(", "\"PostScript format 2\"", ")", ";", "int", "numGlyphStrings", "=", "0", ";", "// Read Number of Glyphs", "int", "l", "=", "in", ".", "readTTFUShort", "(", ")", ";", "// Read indexes", "for", "(", "int", "i", "=", "0", ";", "i", "<", "l", ";", "i", "++", ")", "{", "mtxTab", "[", "i", "]", ".", "setIndex", "(", "in", ".", "readTTFUShort", "(", ")", ")", ";", "if", "(", "mtxTab", "[", "i", "]", ".", "getIndex", "(", ")", ">", "257", ")", "{", "//Index is not in the Macintosh standard set", "numGlyphStrings", "++", ";", "}", "if", "(", "log", ".", "isTraceEnabled", "(", ")", ")", "{", "log", ".", "trace", "(", "\"PostScript index: \"", "+", "mtxTab", "[", "i", "]", ".", "getIndexAsString", "(", ")", ")", ";", "}", "}", "// firstChar=minIndex;", "String", "[", "]", "psGlyphsBuffer", "=", "new", "String", "[", "numGlyphStrings", "]", ";", "if", "(", "log", ".", "isDebugEnabled", "(", ")", ")", "{", "log", ".", "debug", "(", "\"Reading \"", "+", "numGlyphStrings", "+", "\" glyphnames, that are not in the standard Macintosh\"", "+", "\" set. Total number of glyphs=\"", "+", "l", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "psGlyphsBuffer", ".", "length", ";", "i", "++", ")", "{", "psGlyphsBuffer", "[", "i", "]", "=", "in", ".", "readTTFString", "(", "in", ".", "readTTFUByte", "(", ")", ")", ";", "}", "//Set glyph names", "for", "(", "int", "i", "=", "0", ";", "i", "<", "l", ";", "i", "++", ")", "{", "if", "(", "mtxTab", "[", "i", "]", ".", "getIndex", "(", ")", "<", "NMACGLYPHS", ")", "{", "mtxTab", "[", "i", "]", ".", "setName", "(", "Glyphs", ".", "MAC_GLYPH_NAMES", "[", "mtxTab", "[", "i", "]", ".", "getIndex", "(", ")", "]", ")", ";", "}", "else", "{", "if", "(", "!", "mtxTab", "[", "i", "]", ".", "isIndexReserved", "(", ")", ")", "{", "int", "k", "=", "mtxTab", "[", "i", "]", ".", "getIndex", "(", ")", "-", "NMACGLYPHS", ";", "if", "(", "log", ".", "isTraceEnabled", "(", ")", ")", "{", "log", ".", "trace", "(", "k", "+", "\" i=\"", "+", "i", "+", "\" mtx=\"", "+", "mtxTab", ".", "length", "+", "\" ps=\"", "+", "psGlyphsBuffer", ".", "length", ")", ";", "}", "mtxTab", "[", "i", "]", ".", "setName", "(", "psGlyphsBuffer", "[", "k", "]", ")", ";", "}", "}", "}", "break", ";", "case", "0x00030000", ":", "// PostScript format 3 contains no glyph names", "log", ".", "debug", "(", "\"PostScript format 3\"", ")", ";", "break", ";", "default", ":", "log", ".", "error", "(", "\"Unknown PostScript format: \"", "+", "postFormat", ")", ";", "}", "}" ]

[ "Read", "the", "post", "table", "containing", "the", "PostScript", "names", "of", "the", "glyphs", "." ]

[ "protected", "final", "void", "readIndexToLocation", "(", "FontFileReader", "in", ")", "throws", "IOException", "{", "if", "(", "!", "seekTab", "(", "in", ",", "\"loca\"", ",", "0", ")", ")", "{", "throw", "new", "IOException", "(", "\"'loca' table not found, happens when the font file doesn't\"", "+", "\" contain TrueType outlines (trying to read an OpenType CFF font maybe?)\"", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numberOfGlyphs", ";", "i", "++", ")", "{", "mtxTab", "[", "i", "]", ".", "setOffset", "(", "locaFormat", "==", "1", "?", "in", ".", "readTTFULong", "(", ")", ":", "(", "in", ".", "readTTFUShort", "(", ")", "<<", "1", ")", ")", ";", "}", "lastLoca", "=", "(", "locaFormat", "==", "1", "?", "in", ".", "readTTFULong", "(", ")", ":", "(", "in", ".", "readTTFUShort", "(", ")", "<<", "1", ")", ")", ";", "}" ]

[ "Read", "the", "loca", "table", "." ]

[ "private", "final", "void", "readGlyf", "(", "FontFileReader", "in", ")", "throws", "IOException", "{", "TTFDirTabEntry", "dirTab", "=", "(", "TTFDirTabEntry", ")", "dirTabs", ".", "get", "(", "\"glyf\"", ")", ";", "if", "(", "dirTab", "==", "null", ")", "{", "throw", "new", "IOException", "(", "\"glyf table not found, cannot continue\"", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "(", "numberOfGlyphs", "-", "1", ")", ";", "i", "++", ")", "{", "if", "(", "mtxTab", "[", "i", "]", ".", "getOffset", "(", ")", "!=", "mtxTab", "[", "i", "+", "1", "]", ".", "getOffset", "(", ")", ")", "{", "in", ".", "seekSet", "(", "dirTab", ".", "getOffset", "(", ")", "+", "mtxTab", "[", "i", "]", ".", "getOffset", "(", ")", ")", ";", "in", ".", "skip", "(", "2", ")", ";", "final", "int", "[", "]", "bbox", "=", "{", "in", ".", "readTTFShort", "(", ")", ",", "in", ".", "readTTFShort", "(", ")", ",", "in", ".", "readTTFShort", "(", ")", ",", "in", ".", "readTTFShort", "(", ")", "}", ";", "mtxTab", "[", "i", "]", ".", "setBoundingBox", "(", "bbox", ")", ";", "}", "else", "{", "mtxTab", "[", "i", "]", ".", "setBoundingBox", "(", "mtxTab", "[", "0", "]", ".", "getBoundingBox", "(", ")", ")", ";", "}", "}", "long", "n", "=", "(", "(", "TTFDirTabEntry", ")", "dirTabs", ".", "get", "(", "\"glyf\"", ")", ")", ".", "getOffset", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numberOfGlyphs", ";", "i", "++", ")", "{", "if", "(", "(", "i", "+", "1", ")", ">=", "mtxTab", ".", "length", "||", "mtxTab", "[", "i", "]", ".", "getOffset", "(", ")", "!=", "mtxTab", "[", "i", "+", "1", "]", ".", "getOffset", "(", ")", ")", "{", "in", ".", "seekSet", "(", "n", "+", "mtxTab", "[", "i", "]", ".", "getOffset", "(", ")", ")", ";", "in", ".", "skip", "(", "2", ")", ";", "final", "int", "[", "]", "bbox", "=", "{", "in", ".", "readTTFShort", "(", ")", ",", "in", ".", "readTTFShort", "(", ")", ",", "in", ".", "readTTFShort", "(", ")", ",", "in", ".", "readTTFShort", "(", ")", "}", ";", "mtxTab", "[", "i", "]", ".", "setBoundingBox", "(", "bbox", ")", ";", "}", "else", "{", "/**@todo Verify that this is correct, looks like a copy/paste bug (jm)*/", "final", "int", "bbox0", "=", "mtxTab", "[", "0", "]", ".", "getBoundingBox", "(", ")", "[", "0", "]", ";", "final", "int", "[", "]", "bbox", "=", "{", "bbox0", ",", "bbox0", ",", "bbox0", ",", "bbox0", "}", ";", "mtxTab", "[", "i", "]", ".", "setBoundingBox", "(", "bbox", ")", ";", "/* Original code\n mtxTab[i].bbox[0] = mtxTab[0].bbox[0];\n mtxTab[i].bbox[1] = mtxTab[0].bbox[0];\n mtxTab[i].bbox[2] = mtxTab[0].bbox[0];\n mtxTab[i].bbox[3] = mtxTab[0].bbox[0]; */", "}", "if", "(", "log", ".", "isTraceEnabled", "(", ")", ")", "{", "log", ".", "trace", "(", "mtxTab", "[", "i", "]", ".", "toString", "(", "this", ")", ")", ";", "}", "}", "}" ]

[ "Read", "the", "glyf", "table", "to", "find", "the", "bounding", "boxes", "." ]

[ "private", "final", "void", "readName", "(", "FontFileReader", "in", ")", "throws", "IOException", "{", "seekTab", "(", "in", ",", "\"name\"", ",", "2", ")", ";", "int", "i", "=", "in", ".", "getCurrentPos", "(", ")", ";", "int", "n", "=", "in", ".", "readTTFUShort", "(", ")", ";", "int", "j", "=", "in", ".", "readTTFUShort", "(", ")", "+", "i", "-", "2", ";", "i", "+=", "2", "*", "2", ";", "while", "(", "n", "--", ">", "0", ")", "{", "// getLogger().debug(\"Iteration: \" + n);", "in", ".", "seekSet", "(", "i", ")", ";", "final", "int", "platformID", "=", "in", ".", "readTTFUShort", "(", ")", ";", "final", "int", "encodingID", "=", "in", ".", "readTTFUShort", "(", ")", ";", "final", "int", "languageID", "=", "in", ".", "readTTFUShort", "(", ")", ";", "int", "k", "=", "in", ".", "readTTFUShort", "(", ")", ";", "int", "l", "=", "in", ".", "readTTFUShort", "(", ")", ";", "if", "(", "(", "(", "platformID", "==", "1", "||", "platformID", "==", "3", ")", "&&", "(", "encodingID", "==", "0", "||", "encodingID", "==", "1", ")", ")", "&&", "(", "k", "==", "1", "||", "k", "==", "2", "||", "k", "==", "0", "||", "k", "==", "4", "||", "k", "==", "6", ")", ")", "{", "in", ".", "seekSet", "(", "j", "+", "in", ".", "readTTFUShort", "(", ")", ")", ";", "String", "txt", "=", "in", ".", "readTTFString", "(", "l", ")", ";", "log", ".", "debug", "(", "platformID", "+", "\" \"", "+", "encodingID", "+", "\" \"", "+", "languageID", "+", "\" \"", "+", "k", "+", "\" \"", "+", "txt", ")", ";", "switch", "(", "k", ")", "{", "case", "0", ":", "notice", "=", "txt", ";", "break", ";", "case", "1", ":", "familyName", "=", "txt", ";", "break", ";", "case", "2", ":", "subFamilyName", "=", "txt", ";", "break", ";", "case", "4", ":", "fullName", "=", "txt", ";", "break", ";", "case", "6", ":", "fontName", "=", "txt", ";", "break", ";", "}", "if", "(", "!", "notice", ".", "equals", "(", "\"\"", ")", "&&", "!", "fullName", ".", "equals", "(", "\"\"", ")", "&&", "!", "fontName", ".", "equals", "(", "\"\"", ")", "&&", "!", "familyName", ".", "equals", "(", "\"\"", ")", "&&", "!", "subFamilyName", ".", "equals", "(", "\"\"", ")", ")", "{", "break", ";", "}", "}", "i", "+=", "6", "*", "2", ";", "}", "}" ]

[ "Read", "the", "name", "table", "." ]

[ "private", "final", "boolean", "readPCLT", "(", "FontFileReader", "in", ")", "throws", "IOException", "{", "TTFDirTabEntry", "dirTab", "=", "(", "TTFDirTabEntry", ")", "dirTabs", ".", "get", "(", "\"PCLT\"", ")", ";", "if", "(", "dirTab", "!=", "null", ")", "{", "in", ".", "seekSet", "(", "dirTab", ".", "getOffset", "(", ")", "+", "4", "+", "4", "+", "2", ")", ";", "xHeight", "=", "in", ".", "readTTFUShort", "(", ")", ";", "log", ".", "debug", "(", "\"xHeight from PCLT: \"", "+", "xHeight", "+", "\" \"", "+", "(", "xHeight", ")", ")", ";", "in", ".", "skip", "(", "2", "*", "2", ")", ";", "capHeight", "=", "in", ".", "readTTFUShort", "(", ")", ";", "log", ".", "debug", "(", "\"capHeight from PCLT: \"", "+", "capHeight", "+", "\" \"", "+", "(", "capHeight", ")", ")", ";", "in", ".", "skip", "(", "2", "+", "16", "+", "8", "+", "6", "+", "1", "+", "1", ")", ";", "int", "serifStyle", "=", "in", ".", "readTTFUByte", "(", ")", ";", "serifStyle", "=", "serifStyle", ">>", "6", ";", "serifStyle", "=", "serifStyle", "&", "3", ";", "if", "(", "serifStyle", "==", "1", ")", "{", "hasSerifs", "=", "false", ";", "}", "else", "{", "hasSerifs", "=", "true", ";", "}", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}" ]

[ "Read", "the", "PCLT", "table", "to", "find", "xHeight", "and", "capHeight", "." ]

[ "protected", "final", "boolean", "checkTTC", "(", "FontFileReader", "in", ",", "String", "name", ")", "throws", "IOException", "{", "String", "tag", "=", "in", ".", "readTTFString", "(", "4", ")", ";", "if", "(", "\"ttcf\"", ".", "equals", "(", "tag", ")", ")", "{", "// This is a TrueType Collection", "in", ".", "skip", "(", "4", ")", ";", "// Read directory offsets", "int", "numDirectories", "=", "(", "int", ")", "in", ".", "readTTFULong", "(", ")", ";", "// int numDirectories=in.readTTFUShort();", "long", "[", "]", "dirOffsets", "=", "new", "long", "[", "numDirectories", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numDirectories", ";", "i", "++", ")", "{", "dirOffsets", "[", "i", "]", "=", "in", ".", "readTTFULong", "(", ")", ";", "}", "log", ".", "info", "(", "\"This is a TrueType collection file with \"", "+", "numDirectories", "+", "\" fonts\"", ")", ";", "log", ".", "info", "(", "\"Containing the following fonts: \"", ")", ";", "// Read all the directories and name tables to check", "// If the font exists - this is a bit ugly, but...", "boolean", "found", "=", "false", ";", "// Iterate through all name tables even if font", "// Is found, just to show all the names", "long", "dirTabOffset", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "(", "i", "<", "numDirectories", ")", ";", "i", "++", ")", "{", "in", ".", "seekSet", "(", "dirOffsets", "[", "i", "]", ")", ";", "readDirTabs", "(", "in", ")", ";", "readName", "(", "in", ")", ";", "if", "(", "fullName", ".", "equals", "(", "name", ")", ")", "{", "found", "=", "true", ";", "dirTabOffset", "=", "dirOffsets", "[", "i", "]", ";", "log", ".", "info", "(", "fullName", "+", "\" <-- selected\"", ")", ";", "}", "else", "{", "log", ".", "info", "(", "fullName", ")", ";", "}", "// Reset names", "notice", "=", "\"\"", ";", "fullName", "=", "\"\"", ";", "familyName", "=", "\"\"", ";", "fontName", "=", "\"\"", ";", "subFamilyName", "=", "\"\"", ";", "}", "in", ".", "seekSet", "(", "dirTabOffset", ")", ";", "return", "found", ";", "}", "else", "{", "in", ".", "seekSet", "(", "0", ")", ";", "return", "true", ";", "}", "}" ]

[ "Check", "if", "this", "is", "a", "TrueType", "collection", "and", "that", "the", "given", "name", "exists", "in", "the", "collection", ".", "If", "it", "does", "set", "offset", "in", "fontfile", "to", "the", "beginning", "of", "the", "Table", "Directory", "for", "that", "font", "." ]

[ "private", "Integer", "[", "]", "unicodeToWinAnsi", "(", "int", "unicode", ")", "{", "List", "ret", "=", "new", "java", ".", "util", ".", "ArrayList", "(", ")", ";", "for", "(", "int", "i", "=", "32", ";", "i", "<", "Glyphs", ".", "WINANSI_ENCODING", ".", "length", ";", "i", "++", ")", "{", "if", "(", "unicode", "==", "Glyphs", ".", "WINANSI_ENCODING", "[", "i", "]", ")", "{", "ret", ".", "add", "(", "new", "Integer", "(", "i", ")", ")", ";", "}", "}", "return", "(", "Integer", "[", "]", ")", "ret", ".", "toArray", "(", "new", "Integer", "[", "0", "]", ")", ";", "}" ]

[ "Helper", "methods", "they", "are", "not", "very", "efficient", "but", "that", "really", "doesn", "t", "matter", "..." ]

[ "public", "void", "printStuff", "(", ")", "{", "System", ".", "out", ".", "println", "(", "\"Font name: \"", "+", "fontName", ")", ";", "System", ".", "out", ".", "println", "(", "\"Full name: \"", "+", "fullName", ")", ";", "System", ".", "out", ".", "println", "(", "\"Family name: \"", "+", "familyName", ")", ";", "System", ".", "out", ".", "println", "(", "\"Subfamily name: \"", "+", "subFamilyName", ")", ";", "System", ".", "out", ".", "println", "(", "\"Notice: \"", "+", "notice", ")", ";", "System", ".", "out", ".", "println", "(", "\"xHeight: \"", "+", "(", "xHeight", ")", ")", ";", "System", ".", "out", ".", "println", "(", "\"capheight: \"", "+", "(", "capHeight", ")", ")", ";", "int", "italic", "=", "(", "int", ")", "(", "italicAngle", ">>", "16", ")", ";", "System", ".", "out", ".", "println", "(", "\"Italic: \"", "+", "italic", ")", ";", "System", ".", "out", ".", "print", "(", "\"ItalicAngle: \"", "+", "(", "short", ")", "(", "italicAngle", "/", "0x10000", ")", ")", ";", "if", "(", "(", "italicAngle", "%", "0x10000", ")", ">", "0", ")", "{", "System", ".", "out", ".", "print", "(", "\".\"", "+", "(", "short", ")", "(", "(", "italicAngle", "%", "0x10000", ")", "*", "1000", ")", "/", "0x10000", ")", ";", "}", "System", ".", "out", ".", "println", "(", ")", ";", "System", ".", "out", ".", "println", "(", "\"Ascender: \"", "+", "(", "ascender", ")", ")", ";", "System", ".", "out", ".", "println", "(", "\"Descender: \"", "+", "(", "descender", ")", ")", ";", "System", ".", "out", ".", "println", "(", "\"FontBBox: [\"", "+", "(", "fontBBox1", ")", "+", "\" \"", "+", "(", "fontBBox2", ")", "+", "\" \"", "+", "(", "fontBBox3", ")", "+", "\" \"", "+", "(", "fontBBox4", ")", "+", "\"]\"", ")", ";", "}" ]

[ "Dumps", "a", "few", "informational", "values", "to", "System", ".", "out", "." ]

[ "private", "Integer", "unicodeToGlyph", "(", "int", "unicodeIndex", ")", "throws", "IOException", "{", "final", "Integer", "result", "=", "(", "Integer", ")", "unicodeToGlyphMap", ".", "get", "(", "new", "Integer", "(", "unicodeIndex", ")", ")", ";", "if", "(", "result", "==", "null", ")", "{", "throw", "new", "IOException", "(", "\"Glyph index not found for unicode value \"", "+", "unicodeIndex", ")", ";", "}", "return", "result", ";", "}" ]

[ "Map", "a", "unicode", "code", "point", "to", "the", "corresponding", "glyph", "index" ]

[ "public", "static", "void", "main", "(", "String", "[", "]", "args", ")", "{", "try", "{", "TTFFile", "ttfFile", "=", "new", "TTFFile", "(", ")", ";", "FontFileReader", "reader", "=", "new", "FontFileReader", "(", "args", "[", "0", "]", ")", ";", "String", "name", "=", "null", ";", "if", "(", "args", ".", "length", ">=", "2", ")", "{", "name", "=", "args", "[", "1", "]", ";", "}", "ttfFile", ".", "readFont", "(", "reader", ",", "name", ")", ";", "ttfFile", ".", "printStuff", "(", ")", ";", "}", "catch", "(", "IOException", "ioe", ")", "{", "System", ".", "err", ".", "println", "(", "\"Problem reading font: \"", "+", "ioe", ".", "toString", "(", ")", ")", ";", "ioe", ".", "printStackTrace", "(", "System", ".", "err", ")", ";", "}", "}" ]

[ "Static", "main", "method", "to", "get", "info", "about", "a", "TrueType", "font", "." ]

[ "public", "OggData", "getData", "(", "InputStream", "input", ")", "throws", "IOException", "{", "if", "(", "input", "==", "null", ")", "{", "throw", "new", "IOException", "(", "\"Failed to read OGG, source does not exist?\"", ")", ";", "}", "ByteArrayOutputStream", "dataout", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "//\t\tSyncState oy = new SyncState(); // sync and verify incoming physical bitstream\r", "//\t\tStreamState os = new StreamState(); // take physical pages, weld into a logical stream of packets\r", "//\t\tPage og = new Page(); // one Ogg bitstream page. Vorbis packets are inside\r", "//\t\tPacket op = new Packet(); // one raw packet of data for decode\r", "//\r", "//\t\tInfo vi = new Info(); // struct that stores all the static vorbis bitstream settings\r", "//\t\tComment vc = new Comment(); // struct that stores all the bitstream user comments\r", "//\t\tDspState vd = new DspState(); // central working state for the packet->PCM decoder\r", "//\t\tBlock vb = new Block(vd); // local working space for packet->PCM decode\r", "//\r", "//\t\tbyte[] buffer;\r", "//\t\tint bytes = 0;\r", "//\r", "//\t\tboolean bigEndian = ByteOrder.nativeOrder().equals(ByteOrder.BIG_ENDIAN);\r", "//\t\t// Decode setup\r", "//\r", "//\t\toy.init(); // Now we can read pages\r", "//\r", "//\t\twhile (true) { // we repeat if the bitstream is chained\r", "//\t\t\tint eos = 0;\r", "//\r", "//\t\t\t// grab some data at the head of the stream. We want the first page\r", "//\t\t\t// (which is guaranteed to be small and only contain the Vorbis\r", "//\t\t\t// stream initial header) We need the first page to get the stream\r", "//\t\t\t// serialno.\r", "//\r", "//\t\t\t// submit a 4k block to libvorbis' Ogg layer\r", "//\t\t\tint index = oy.buffer(4096);\r", "//\t\t\t\r", "//\t\t\tbuffer = oy.data;\r", "//\t\t\ttry {\r", "//\t\t\t\tbytes = input.read(buffer, index, 4096);\r", "//\t\t\t} catch (Exception e) {\r", "//\t\t\t\tLog.error(\"Failure reading in vorbis\");\r", "//\t\t\t\tLog.error(e);\r", "//\t\t\t\tSystem.exit(0);\r", "//\t\t\t}\r", "//\t\t\toy.wrote(bytes);\r", "//\r", "//\t\t\t// Get the first page.\r", "//\t\t\tif (oy.pageout(og) != 1) {\r", "//\t\t\t\t// have we simply run out of data? If so, we're done.\r", "//\t\t\t\tif (bytes < 4096)\r", "//\t\t\t\t\tbreak;\r", "//\r", "//\t\t\t\t// error case. Must not be Vorbis data\r", "//\t\t\t\tLog.error(\"Input does not appear to be an Ogg bitstream.\");\r", "//\t\t\t\tSystem.exit(0);\r", "//\t\t\t}\r", "//\r", "//\t\t\t// Get the serial number and set up the rest of decode.\r", "//\t\t\t// serialno first; use it to set up a logical stream\r", "//\t\t\tos.init(og.serialno());\r", "//\r", "//\t\t\t// extract the initial header from the first page and verify that the\r", "//\t\t\t// Ogg bitstream is in fact Vorbis data\r", "//\r", "//\t\t\t// I handle the initial header first instead of just having the code\r", "//\t\t\t// read all three Vorbis headers at once because reading the initial\r", "//\t\t\t// header is an easy way to identify a Vorbis bitstream and it's\r", "//\t\t\t// useful to see that functionality seperated out.\r", "//\r", "//\t\t\tvi.init();\r", "//\t\t\tvc.init();\r", "//\t\t\tif (os.pagein(og) < 0) {\r", "//\t\t\t\t// error; stream version mismatch perhaps\r", "//\t\t\t\tLog.error(\"Error reading first page of Ogg bitstream data.\");\r", "//\t\t\t\tSystem.exit(0);\r", "//\t\t\t}\r", "//\r", "//\t\t\tif (os.packetout(op) != 1) {\r", "//\t\t\t\t// no page? must not be vorbis\r", "//\t\t\t\tLog.error(\"Error reading initial header packet.\");\r", "//\t\t\t\tSystem.exit(0);\r", "//\t\t\t}\r", "//\r", "//\t\t\tif (vi.synthesis_headerin(vc, op) < 0) {\r", "//\t\t\t\t// error case; not a vorbis header\r", "//\t\t\t\tLog.error(\"This Ogg bitstream does not contain Vorbis audio data.\");\r", "//\t\t\t\tSystem.exit(0);\r", "//\t\t\t}\r", "//\r", "//\t\t\t// At this point, we're sure we're Vorbis. We've set up the logical\r", "//\t\t\t// (Ogg) bitstream decoder. Get the comment and codebook headers and\r", "//\t\t\t// set up the Vorbis decoder\r", "//\r", "//\t\t\t// The next two packets in order are the comment and codebook headers.\r", "//\t\t\t// They're likely large and may span multiple pages. Thus we reead\r", "//\t\t\t// and submit data until we get our two pacakets, watching that no\r", "//\t\t\t// pages are missing. If a page is missing, error out; losing a\r", "//\t\t\t// header page is the only place where missing data is fatal. */\r", "//\r", "//\t\t\tint i = 0;\r", "//\t\t\twhile (i < 2) {\r", "//\t\t\t\twhile (i < 2) {\r", "//\r", "//\t\t\t\t\tint result = oy.pageout(og);\r", "//\t\t\t\t\tif (result == 0)\r", "//\t\t\t\t\t\tbreak; // Need more data\r", "//\t\t\t\t\t// Don't complain about missing or corrupt data yet. We'll\r", "//\t\t\t\t\t// catch it at the packet output phase\r", "//\r", "//\t\t\t\t\tif (result == 1) {\r", "//\t\t\t\t\t\tos.pagein(og); // we can ignore any errors here\r", "//\t\t\t\t\t\t// as they'll also become apparent\r", "//\t\t\t\t\t\t// at packetout\r", "//\t\t\t\t\t\twhile (i < 2) {\r", "//\t\t\t\t\t\t\tresult = os.packetout(op);\r", "//\t\t\t\t\t\t\tif (result == 0)\r", "//\t\t\t\t\t\t\t\tbreak;\r", "//\t\t\t\t\t\t\tif (result == -1) {\r", "//\t\t\t\t\t\t\t\t// Uh oh; data at some point was corrupted or missing!\r", "//\t\t\t\t\t\t\t\t// We can't tolerate that in a header. Die.\r", "//\t\t\t\t\t\t\t\tLog.error(\"Corrupt secondary header. Exiting.\");\r", "//\t\t\t\t\t\t\t\tSystem.exit(0);\r", "//\t\t\t\t\t\t\t}\r", "//\t\t\t\t\t\t\tvi.synthesis_headerin(vc, op);\r", "//\t\t\t\t\t\t\ti++;\r", "//\t\t\t\t\t\t}\r", "//\t\t\t\t\t}\r", "//\t\t\t\t}\r", "//\t\t\t\t// no harm in not checking before adding more\r", "//\t\t\t\tindex = oy.buffer(4096);\r", "//\t\t\t\tbuffer = oy.data;\r", "//\t\t\t\ttry {\r", "//\t\t\t\t\tbytes = input.read(buffer, index, 4096);\r", "//\t\t\t\t} catch (Exception e) {\r", "//\t\t\t\t\tLog.error(\"Failed to read Vorbis: \");\r", "//\t\t\t\t\tLog.error(e);\r", "//\t\t\t\t\tSystem.exit(0);\r", "//\t\t\t\t}\r", "//\t\t\t\tif (bytes == 0 && i < 2) {\r", "//\t\t\t\t\tLog.error(\"End of file before finding all Vorbis headers!\");\r", "//\t\t\t\t\tSystem.exit(0);\r", "//\t\t\t\t}\r", "//\t\t\t\toy.wrote(bytes);\r", "//\t\t\t}\r", "//\r", "//\t\t\tconvsize = 4096 / vi.channels;\r", "//\r", "//\t\t\t// OK, got and parsed all three headers. Initialize the Vorbis\r", "//\t\t\t// packet->PCM decoder.\r", "//\t\t\tvd.synthesis_init(vi); // central decode state\r", "//\t\t\tvb.init(vd); // local state for most of the decode\r", "//\t\t\t// so multiple block decodes can\r", "//\t\t\t// proceed in parallel. We could init\r", "//\t\t\t// multiple vorbis_block structures\r", "//\t\t\t// for vd here\r", "//\r", "//\t\t\tfloat[][][] _pcm = new float[1][][];\r", "//\t\t\tint[] _index = new int[vi.channels];\r", "//\t\t\t// The rest is just a straight decode loop until end of stream\r", "//\t\t\twhile (eos == 0) {\r", "//\t\t\t\twhile (eos == 0) {\r", "//\r", "//\t\t\t\t\tint result = oy.pageout(og);\r", "//\t\t\t\t\tif (result == 0)\r", "//\t\t\t\t\t\tbreak; // need more data\r", "//\t\t\t\t\tif (result == -1) { // missing or corrupt data at this page position\r", "//\t\t\t\t\t\tLog.error(\"Corrupt or missing data in bitstream; continuing...\");\r", "//\t\t\t\t\t} else {\r", "//\t\t\t\t\t\tos.pagein(og); // can safely ignore errors at\r", "//\t\t\t\t\t\t// this point\r", "//\t\t\t\t\t\twhile (true) {\r", "//\t\t\t\t\t\t\tresult = os.packetout(op);\r", "//\r", "//\t\t\t\t\t\t\tif (result == 0)\r", "//\t\t\t\t\t\t\t\tbreak; // need more data\r", "//\t\t\t\t\t\t\tif (result == -1) { // missing or corrupt data at this page position\r", "//\t\t\t\t\t\t\t\t// no reason to complain; already complained above\r", "//\t\t\t\t\t\t\t} else {\r", "//\t\t\t\t\t\t\t\t// we have a packet. Decode it\r", "//\t\t\t\t\t\t\t\tint samples;\r", "//\t\t\t\t\t\t\t\tif (vb.synthesis(op) == 0) { // test for success!\r", "//\t\t\t\t\t\t\t\t\tvd.synthesis_blockin(vb);\r", "//\t\t\t\t\t\t\t\t}\r", "//\r", "//\t\t\t\t\t\t\t\t// **pcm is a multichannel float vector. In stereo, for\r", "//\t\t\t\t\t\t\t\t// example, pcm[0] is left, and pcm[1] is right. samples is\r", "//\t\t\t\t\t\t\t\t// the size of each channel. Convert the float values\r", "//\t\t\t\t\t\t\t\t// (-1.<=range<=1.) to whatever PCM format and write it out\r", "//\r", "//\t\t\t\t\t\t\t\twhile ((samples = vd.synthesis_pcmout(_pcm,\r", "//\t\t\t\t\t\t\t\t\t\t_index)) > 0) {\r", "//\t\t\t\t\t\t\t\t\tfloat[][] pcm = _pcm[0];\r", "//\t\t\t\t\t\t\t\t\t//boolean clipflag = false;\r", "//\t\t\t\t\t\t\t\t\tint bout = (samples < convsize ? samples\r", "//\t\t\t\t\t\t\t\t\t\t\t: convsize);\r", "//\r", "//\t\t\t\t\t\t\t\t\t// convert floats to 16 bit signed ints (host order) and\r", "//\t\t\t\t\t\t\t\t\t// interleave\r", "//\t\t\t\t\t\t\t\t\tfor (i = 0; i < vi.channels; i++) {\r", "//\t\t\t\t\t\t\t\t\t\tint ptr = i * 2;\r", "//\t\t\t\t\t\t\t\t\t\t//int ptr=i;\r", "//\t\t\t\t\t\t\t\t\t\tint mono = _index[i];\r", "//\t\t\t\t\t\t\t\t\t\tfor (int j = 0; j < bout; j++) {\r", "//\t\t\t\t\t\t\t\t\t\t\tint val = (int) (pcm[i][mono + j] * 32767.);\r", "//\t\t\t\t\t\t\t\t\t\t\t//\t\t\t short val=(short)(pcm[i][mono+j]*32767.);\r", "//\t\t\t\t\t\t\t\t\t\t\t//\t\t\t int val=(int)Math.round(pcm[i][mono+j]*32767.);\r", "//\t\t\t\t\t\t\t\t\t\t\t// might as well guard against clipping\r", "//\t\t\t\t\t\t\t\t\t\t\tif (val > 32767) {\r", "//\t\t\t\t\t\t\t\t\t\t\t\tval = 32767;\r", "//\t\t\t\t\t\t\t\t\t\t\t\t//clipflag = true;\r", "//\t\t\t\t\t\t\t\t\t\t\t}\r", "//\t\t\t\t\t\t\t\t\t\t\tif (val < -32768) {\r", "//\t\t\t\t\t\t\t\t\t\t\t\tval = -32768;\r", "//\t\t\t\t\t\t\t\t\t\t\t\t//clipflag = true;\r", "//\t\t\t\t\t\t\t\t\t\t\t}\r", "//\t\t\t\t\t\t\t\t\t\t\tif (val < 0)\r", "//\t\t\t\t\t\t\t\t\t\t\t\tval = val | 0x8000;\r", "//\t\t\t\t\r", "//\t\t\t\t\t\t\t\t\t\t\tif (bigEndian) {\r", "//\t\t\t\t\t\t\t\t\t\t\t\tconvbuffer[ptr] = (byte) (val >>> 8);\r", "//\t\t\t\t\t\t\t\t\t\t\t\tconvbuffer[ptr + 1] = (byte) (val);\r", "//\t\t\t\t\t\t\t\t\t\t\t} else {\r", "//\t\t\t\t\t\t\t\t\t\t\t\tconvbuffer[ptr] = (byte) (val);\r", "//\t\t\t\t\t\t\t\t\t\t\t\tconvbuffer[ptr + 1] = (byte) (val >>> 8);\r", "//\t\t\t\t\t\t\t\t\t\t\t}\r", "//\t\t\t\t\t\t\t\t\t\t\tptr += 2 * (vi.channels);\r", "//\t\t\t\t\t\t\t\t\t\t}\r", "//\t\t\t\t\t\t\t\t\t}\r", "//\r", "//\t\t\t\t\t\t\t\t\tdataout.write(convbuffer, 0, 2 * vi.channels * bout);\r", "//\r", "//\t\t\t\t\t\t\t\t\tvd.synthesis_read(bout); // tell libvorbis how\r", "//\t\t\t\t\t\t\t\t\t// many samples we\r", "//\t\t\t\t\t\t\t\t\t// actually consumed\r", "//\t\t\t\t\t\t\t\t}\r", "//\t\t\t\t\t\t\t}\r", "//\t\t\t\t\t\t}\r", "//\t\t\t\t\t\tif (og.eos() != 0)\r", "//\t\t\t\t\t\t\teos = 1;\r", "//\t\t\t\t\t}\r", "//\t\t\t\t}\r", "//\t\t\t\tif (eos == 0) {\r", "//\t\t\t\t\tindex = oy.buffer(4096);\r", "//\t\t\t\t\tif (index >= 0) {\r", "//\t\t\t\t\t\tbuffer = oy.data;\r", "//\t\t\t\t\t\ttry {\r", "//\t\t\t\t\t\t\tbytes = input.read(buffer, index, 4096);\r", "//\t\t\t\t\t\t} catch (Exception e) {\r", "//\t\t\t\t\t\t\tLog.error(\"Failure during vorbis decoding\");\r", "//\t\t\t\t\t\t\tLog.error(e);\r", "//\t\t\t\t\t\t\treturn null;\r", "//\t\t\t\t\t\t}\r", "//\t\t\t\t\t} else {\r", "//\t\t\t\t\t\tbytes = 0;\r", "//\t\t\t\t\t}\r", "//\t\t\t\t\toy.wrote(bytes);\r", "//\t\t\t\t\tif (bytes == 0)\r", "//\t\t\t\t\t\teos = 1;\r", "//\t\t\t\t}\r", "//\t\t\t}\r", "//\r", "//\t\t\t// clean up this logical bitstream; before exit we see if we're\r", "//\t\t\t// followed by another [chained]\r", "//\r", "//\t\t\tos.clear();\r", "//\r", "//\t\t\t// ogg_page and ogg_packet structs always point to storage in\r", "//\t\t\t// libvorbis. They're never freed or manipulated directly\r", "//\r", "//\t\t\tvb.clear();\r", "//\t\t\tvd.clear();\r", "//\t\t\tvi.clear(); // must be called last\r", "//\t\t}\r", "//\r", "//\t\t// OK, clean up the framer\r", "//\t\toy.clear();\r", "//\t\tOggData ogg = new OggData();\r", "//\t\togg.channels = vi.channels;\r", "//\t\togg.rate = vi.rate;\r", "OggInputStream", "oggInput", "=", "new", "OggInputStream", "(", "input", ")", ";", "boolean", "done", "=", "false", ";", "while", "(", "!", "oggInput", ".", "atEnd", "(", ")", ")", "{", "dataout", ".", "write", "(", "oggInput", ".", "read", "(", ")", ")", ";", "}", "OggData", "ogg", "=", "new", "OggData", "(", ")", ";", "ogg", ".", "channels", "=", "oggInput", ".", "getChannels", "(", ")", ";", "ogg", ".", "rate", "=", "oggInput", ".", "getRate", "(", ")", ";", "byte", "[", "]", "data", "=", "dataout", ".", "toByteArray", "(", ")", ";", "ogg", ".", "data", "=", "ByteBuffer", ".", "allocateDirect", "(", "data", ".", "length", ")", ";", "ogg", ".", "data", ".", "put", "(", "data", ")", ";", "ogg", ".", "data", ".", "rewind", "(", ")", ";", "return", "ogg", ";", "}" ]

[ "Get", "the", "data", "out", "of", "an", "OGG", "file" ]

[ "private", "void", "createDirectory", "(", ")", "{", "int", "numTables", "=", "9", ";", "// Create the TrueType header", "writeByte", "(", "(", "byte", ")", "0", ")", ";", "writeByte", "(", "(", "byte", ")", "1", ")", ";", "writeByte", "(", "(", "byte", ")", "0", ")", ";", "writeByte", "(", "(", "byte", ")", "0", ")", ";", "realSize", "+=", "4", ";", "writeUShort", "(", "numTables", ")", ";", "realSize", "+=", "2", ";", "// Create searchRange, entrySelector and rangeShift", "int", "maxPow", "=", "maxPow2", "(", "numTables", ")", ";", "int", "searchRange", "=", "maxPow", "*", "16", ";", "writeUShort", "(", "searchRange", ")", ";", "realSize", "+=", "2", ";", "writeUShort", "(", "maxPow", ")", ";", "realSize", "+=", "2", ";", "writeUShort", "(", "(", "numTables", "*", "16", ")", "-", "searchRange", ")", ";", "realSize", "+=", "2", ";", "// Create space for the table entries", "writeString", "(", "\"cvt \"", ")", ";", "cvtDirOffset", "=", "currentPos", ";", "currentPos", "+=", "12", ";", "realSize", "+=", "16", ";", "if", "(", "hasFpgm", "(", ")", ")", "{", "writeString", "(", "\"fpgm\"", ")", ";", "fpgmDirOffset", "=", "currentPos", ";", "currentPos", "+=", "12", ";", "realSize", "+=", "16", ";", "}", "writeString", "(", "\"glyf\"", ")", ";", "glyfDirOffset", "=", "currentPos", ";", "currentPos", "+=", "12", ";", "realSize", "+=", "16", ";", "writeString", "(", "\"head\"", ")", ";", "headDirOffset", "=", "currentPos", ";", "currentPos", "+=", "12", ";", "realSize", "+=", "16", ";", "writeString", "(", "\"hhea\"", ")", ";", "hheaDirOffset", "=", "currentPos", ";", "currentPos", "+=", "12", ";", "realSize", "+=", "16", ";", "writeString", "(", "\"hmtx\"", ")", ";", "hmtxDirOffset", "=", "currentPos", ";", "currentPos", "+=", "12", ";", "realSize", "+=", "16", ";", "writeString", "(", "\"loca\"", ")", ";", "locaDirOffset", "=", "currentPos", ";", "currentPos", "+=", "12", ";", "realSize", "+=", "16", ";", "writeString", "(", "\"maxp\"", ")", ";", "maxpDirOffset", "=", "currentPos", ";", "currentPos", "+=", "12", ";", "realSize", "+=", "16", ";", "writeString", "(", "\"prep\"", ")", ";", "prepDirOffset", "=", "currentPos", ";", "currentPos", "+=", "12", ";", "realSize", "+=", "16", ";", "}" ]

[ "Create", "the", "directory", "table" ]

[ "private", "void", "createCvt", "(", "FontFileReader", "in", ")", "throws", "IOException", "{", "TTFDirTabEntry", "entry", "=", "(", "TTFDirTabEntry", ")", "dirTabs", ".", "get", "(", "\"cvt \"", ")", ";", "if", "(", "entry", "!=", "null", ")", "{", "pad4", "(", ")", ";", "seekTab", "(", "in", ",", "\"cvt \"", ",", "0", ")", ";", "System", ".", "arraycopy", "(", "in", ".", "getBytes", "(", "(", "int", ")", "entry", ".", "getOffset", "(", ")", ",", "(", "int", ")", "entry", ".", "getLength", "(", ")", ")", ",", "0", ",", "output", ",", "currentPos", ",", "(", "int", ")", "entry", ".", "getLength", "(", ")", ")", ";", "int", "checksum", "=", "getCheckSum", "(", "currentPos", ",", "(", "int", ")", "entry", ".", "getLength", "(", ")", ")", ";", "writeULong", "(", "cvtDirOffset", ",", "checksum", ")", ";", "writeULong", "(", "cvtDirOffset", "+", "4", ",", "currentPos", ")", ";", "writeULong", "(", "cvtDirOffset", "+", "8", ",", "(", "int", ")", "entry", ".", "getLength", "(", ")", ")", ";", "currentPos", "+=", "(", "int", ")", "entry", ".", "getLength", "(", ")", ";", "realSize", "+=", "(", "int", ")", "entry", ".", "getLength", "(", ")", ";", "}", "else", "{", "throw", "new", "IOException", "(", "\"Can't find cvt table\"", ")", ";", "}", "}" ]

[ "Copy", "the", "cvt", "table", "as", "is", "from", "original", "font", "to", "subset", "font" ]

[ "private", "void", "createLoca", "(", "int", "size", ")", "throws", "IOException", "{", "pad4", "(", ")", ";", "locaOffset", "=", "currentPos", ";", "writeULong", "(", "locaDirOffset", "+", "4", ",", "currentPos", ")", ";", "writeULong", "(", "locaDirOffset", "+", "8", ",", "size", "*", "4", "+", "4", ")", ";", "currentPos", "+=", "size", "*", "4", "+", "4", ";", "realSize", "+=", "size", "*", "4", "+", "4", ";", "}" ]

[ "Create", "an", "empty", "loca", "table", "without", "updating", "checksum" ]

[ "private", "void", "createMaxp", "(", "FontFileReader", "in", ",", "int", "size", ")", "throws", "IOException", "{", "TTFDirTabEntry", "entry", "=", "(", "TTFDirTabEntry", ")", "dirTabs", ".", "get", "(", "\"maxp\"", ")", ";", "if", "(", "entry", "!=", "null", ")", "{", "pad4", "(", ")", ";", "seekTab", "(", "in", ",", "\"maxp\"", ",", "0", ")", ";", "System", ".", "arraycopy", "(", "in", ".", "getBytes", "(", "(", "int", ")", "entry", ".", "getOffset", "(", ")", ",", "(", "int", ")", "entry", ".", "getLength", "(", ")", ")", ",", "0", ",", "output", ",", "currentPos", ",", "(", "int", ")", "entry", ".", "getLength", "(", ")", ")", ";", "writeUShort", "(", "currentPos", "+", "4", ",", "size", ")", ";", "int", "checksum", "=", "getCheckSum", "(", "currentPos", ",", "(", "int", ")", "entry", ".", "getLength", "(", ")", ")", ";", "writeULong", "(", "maxpDirOffset", ",", "checksum", ")", ";", "writeULong", "(", "maxpDirOffset", "+", "4", ",", "currentPos", ")", ";", "writeULong", "(", "maxpDirOffset", "+", "8", ",", "(", "int", ")", "entry", ".", "getLength", "(", ")", ")", ";", "currentPos", "+=", "(", "int", ")", "entry", ".", "getLength", "(", ")", ";", "realSize", "+=", "(", "int", ")", "entry", ".", "getLength", "(", ")", ";", "}", "else", "{", "throw", "new", "IOException", "(", "\"Can't find maxp table\"", ")", ";", "}", "}" ]

[ "Copy", "the", "maxp", "table", "as", "is", "from", "original", "font", "to", "subset", "font", "and", "set", "num", "glyphs", "to", "size" ]

[ "private", "void", "createHead", "(", "FontFileReader", "in", ")", "throws", "IOException", "{", "TTFDirTabEntry", "entry", "=", "(", "TTFDirTabEntry", ")", "dirTabs", ".", "get", "(", "\"head\"", ")", ";", "if", "(", "entry", "!=", "null", ")", "{", "pad4", "(", ")", ";", "seekTab", "(", "in", ",", "\"head\"", ",", "0", ")", ";", "System", ".", "arraycopy", "(", "in", ".", "getBytes", "(", "(", "int", ")", "entry", ".", "getOffset", "(", ")", ",", "(", "int", ")", "entry", ".", "getLength", "(", ")", ")", ",", "0", ",", "output", ",", "currentPos", ",", "(", "int", ")", "entry", ".", "getLength", "(", ")", ")", ";", "checkSumAdjustmentOffset", "=", "currentPos", "+", "8", ";", "output", "[", "currentPos", "+", "8", "]", "=", "0", ";", "// Set checkSumAdjustment to 0", "output", "[", "currentPos", "+", "9", "]", "=", "0", ";", "output", "[", "currentPos", "+", "10", "]", "=", "0", ";", "output", "[", "currentPos", "+", "11", "]", "=", "0", ";", "output", "[", "currentPos", "+", "50", "]", "=", "0", ";", "// long locaformat", "output", "[", "currentPos", "+", "51", "]", "=", "1", ";", "// long locaformat", "int", "checksum", "=", "getCheckSum", "(", "currentPos", ",", "(", "int", ")", "entry", ".", "getLength", "(", ")", ")", ";", "writeULong", "(", "headDirOffset", ",", "checksum", ")", ";", "writeULong", "(", "headDirOffset", "+", "4", ",", "currentPos", ")", ";", "writeULong", "(", "headDirOffset", "+", "8", ",", "(", "int", ")", "entry", ".", "getLength", "(", ")", ")", ";", "currentPos", "+=", "(", "int", ")", "entry", ".", "getLength", "(", ")", ";", "realSize", "+=", "(", "int", ")", "entry", ".", "getLength", "(", ")", ";", "}", "else", "{", "throw", "new", "IOException", "(", "\"Can't find head table\"", ")", ";", "}", "}" ]

[ "Copy", "the", "head", "table", "as", "is", "from", "original", "font", "to", "subset", "font", "and", "set", "indexToLocaFormat", "to", "long", "and", "set", "checkSumAdjustment", "to", "0", "store", "offset", "to", "checkSumAdjustment", "in", "checkSumAdjustmentOffset" ]

[ "private", "void", "createGlyf", "(", "FontFileReader", "in", ",", "Map", "glyphs", ")", "throws", "IOException", "{", "TTFDirTabEntry", "entry", "=", "(", "TTFDirTabEntry", ")", "dirTabs", ".", "get", "(", "\"glyf\"", ")", ";", "int", "size", "=", "0", ";", "int", "start", "=", "0", ";", "int", "endOffset", "=", "0", ";", "// Store this as the last loca", "if", "(", "entry", "!=", "null", ")", "{", "pad4", "(", ")", ";", "start", "=", "currentPos", ";", "/* Loca table must be in order by glyph index, so build\n * an array first and then write the glyph info and\n * location offset.\n */", "int", "[", "]", "origIndexes", "=", "new", "int", "[", "glyphs", ".", "size", "(", ")", "]", ";", "Iterator", "e", "=", "glyphs", ".", "keySet", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "e", ".", "hasNext", "(", ")", ")", "{", "Integer", "origIndex", "=", "(", "Integer", ")", "e", ".", "next", "(", ")", ";", "Integer", "subsetIndex", "=", "(", "Integer", ")", "glyphs", ".", "get", "(", "origIndex", ")", ";", "origIndexes", "[", "subsetIndex", ".", "intValue", "(", ")", "]", "=", "origIndex", ".", "intValue", "(", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "origIndexes", ".", "length", ";", "i", "++", ")", "{", "int", "glyphLength", "=", "0", ";", "int", "nextOffset", "=", "0", ";", "int", "origGlyphIndex", "=", "origIndexes", "[", "i", "]", ";", "if", "(", "origGlyphIndex", ">=", "(", "mtxTab", ".", "length", "-", "1", ")", ")", "{", "nextOffset", "=", "(", "int", ")", "lastLoca", ";", "}", "else", "{", "nextOffset", "=", "(", "int", ")", "mtxTab", "[", "origGlyphIndex", "+", "1", "]", ".", "getOffset", "(", ")", ";", "}", "glyphLength", "=", "nextOffset", "-", "(", "int", ")", "mtxTab", "[", "origGlyphIndex", "]", ".", "getOffset", "(", ")", ";", "// Copy glyph", "System", ".", "arraycopy", "(", "in", ".", "getBytes", "(", "(", "int", ")", "entry", ".", "getOffset", "(", ")", "+", "(", "int", ")", "mtxTab", "[", "origGlyphIndex", "]", ".", "getOffset", "(", ")", ",", "glyphLength", ")", ",", "0", ",", "output", ",", "currentPos", ",", "glyphLength", ")", ";", "// Update loca table", "writeULong", "(", "locaOffset", "+", "i", "*", "4", ",", "currentPos", "-", "start", ")", ";", "if", "(", "(", "currentPos", "-", "start", "+", "glyphLength", ")", ">", "endOffset", ")", "{", "endOffset", "=", "(", "currentPos", "-", "start", "+", "glyphLength", ")", ";", "}", "currentPos", "+=", "glyphLength", ";", "realSize", "+=", "glyphLength", ";", "}", "size", "=", "currentPos", "-", "start", ";", "int", "checksum", "=", "getCheckSum", "(", "start", ",", "size", ")", ";", "writeULong", "(", "glyfDirOffset", ",", "checksum", ")", ";", "writeULong", "(", "glyfDirOffset", "+", "4", ",", "start", ")", ";", "writeULong", "(", "glyfDirOffset", "+", "8", ",", "size", ")", ";", "currentPos", "+=", "12", ";", "realSize", "+=", "12", ";", "// Update loca checksum and last loca index", "writeULong", "(", "locaOffset", "+", "glyphs", ".", "size", "(", ")", "*", "4", ",", "endOffset", ")", ";", "checksum", "=", "getCheckSum", "(", "locaOffset", ",", "glyphs", ".", "size", "(", ")", "*", "4", "+", "4", ")", ";", "writeULong", "(", "locaDirOffset", ",", "checksum", ")", ";", "}", "else", "{", "throw", "new", "IOException", "(", "\"Can't find glyf table\"", ")", ";", "}", "}" ]

[ "Create", "the", "glyf", "table", "and", "fill", "in", "loca", "table" ]

[ "private", "List", "getIncludedGlyphs", "(", "FontFileReader", "in", ",", "int", "glyphOffset", ",", "Integer", "glyphIdx", ")", "throws", "IOException", "{", "List", "ret", "=", "new", "ArrayList", "(", ")", ";", "ret", ".", "add", "(", "glyphIdx", ")", ";", "int", "offset", "=", "glyphOffset", "+", "(", "int", ")", "mtxTab", "[", "glyphIdx", ".", "intValue", "(", ")", "]", ".", "getOffset", "(", ")", "+", "10", ";", "Integer", "compositeIdx", "=", "null", ";", "int", "flags", "=", "0", ";", "boolean", "moreComposites", "=", "true", ";", "while", "(", "moreComposites", ")", "{", "flags", "=", "in", ".", "readTTFUShort", "(", "offset", ")", ";", "compositeIdx", "=", "new", "Integer", "(", "in", ".", "readTTFUShort", "(", "offset", "+", "2", ")", ")", ";", "ret", ".", "add", "(", "compositeIdx", ")", ";", "offset", "+=", "4", ";", "if", "(", "(", "flags", "&", "1", ")", ">", "0", ")", "{", "// ARG_1_AND_ARG_2_ARE_WORDS", "offset", "+=", "4", ";", "}", "else", "{", "offset", "+=", "2", ";", "}", "if", "(", "(", "flags", "&", "8", ")", ">", "0", ")", "{", "offset", "+=", "2", ";", "// WE_HAVE_A_SCALE", "}", "else", "if", "(", "(", "flags", "&", "64", ")", ">", "0", ")", "{", "offset", "+=", "4", ";", "// WE_HAVE_AN_X_AND_Y_SCALE", "}", "else", "if", "(", "(", "flags", "&", "128", ")", ">", "0", ")", "{", "offset", "+=", "8", ";", "// WE_HAVE_A_TWO_BY_TWO", "}", "if", "(", "(", "flags", "&", "32", ")", ">", "0", ")", "{", "moreComposites", "=", "true", ";", "}", "else", "{", "moreComposites", "=", "false", ";", "}", "}", "return", "ret", ";", "}" ]

[ "Returns", "a", "List", "containing", "the", "glyph", "itself", "plus", "all", "glyphs", "that", "this", "composite", "glyph", "uses" ]

[ "private", "void", "remapComposite", "(", "FontFileReader", "in", ",", "Map", "glyphs", ",", "int", "glyphOffset", ",", "Integer", "glyphIdx", ")", "throws", "IOException", "{", "int", "offset", "=", "glyphOffset", "+", "(", "int", ")", "mtxTab", "[", "glyphIdx", ".", "intValue", "(", ")", "]", ".", "getOffset", "(", ")", "+", "10", ";", "Integer", "compositeIdx", "=", "null", ";", "int", "flags", "=", "0", ";", "boolean", "moreComposites", "=", "true", ";", "while", "(", "moreComposites", ")", "{", "flags", "=", "in", ".", "readTTFUShort", "(", "offset", ")", ";", "compositeIdx", "=", "new", "Integer", "(", "in", ".", "readTTFUShort", "(", "offset", "+", "2", ")", ")", ";", "Integer", "newIdx", "=", "(", "Integer", ")", "glyphs", ".", "get", "(", "compositeIdx", ")", ";", "if", "(", "newIdx", "==", "null", ")", "{", "// This errormessage would look much better", "// if the fontname was printed to", "//log.error(\"An embedded font \"", "// + \"contains bad glyph data. \"", "// + \"Characters might not display \"", "// + \"correctly.\");", "moreComposites", "=", "false", ";", "continue", ";", "}", "in", ".", "writeTTFUShort", "(", "offset", "+", "2", ",", "newIdx", ".", "intValue", "(", ")", ")", ";", "offset", "+=", "4", ";", "if", "(", "(", "flags", "&", "1", ")", ">", "0", ")", "{", "// ARG_1_AND_ARG_2_ARE_WORDS", "offset", "+=", "4", ";", "}", "else", "{", "offset", "+=", "2", ";", "}", "if", "(", "(", "flags", "&", "8", ")", ">", "0", ")", "{", "offset", "+=", "2", ";", "// WE_HAVE_A_SCALE", "}", "else", "if", "(", "(", "flags", "&", "64", ")", ">", "0", ")", "{", "offset", "+=", "4", ";", "// WE_HAVE_AN_X_AND_Y_SCALE", "}", "else", "if", "(", "(", "flags", "&", "128", ")", ">", "0", ")", "{", "offset", "+=", "8", ";", "// WE_HAVE_A_TWO_BY_TWO", "}", "if", "(", "(", "flags", "&", "32", ")", ">", "0", ")", "{", "moreComposites", "=", "true", ";", "}", "else", "{", "moreComposites", "=", "false", ";", "}", "}", "}" ]

[ "Rewrite", "all", "compositepointers", "in", "glyphindex", "glyphIdx" ]

[ "private", "void", "scanGlyphs", "(", "FontFileReader", "in", ",", "Map", "glyphs", ")", "throws", "IOException", "{", "TTFDirTabEntry", "entry", "=", "(", "TTFDirTabEntry", ")", "dirTabs", ".", "get", "(", "\"glyf\"", ")", ";", "Map", "newComposites", "=", "null", ";", "Map", "allComposites", "=", "new", "java", ".", "util", ".", "HashMap", "(", ")", ";", "int", "newIndex", "=", "glyphs", ".", "size", "(", ")", ";", "if", "(", "entry", "!=", "null", ")", "{", "while", "(", "newComposites", "==", "null", "||", "newComposites", ".", "size", "(", ")", ">", "0", ")", "{", "// Inefficient to iterate through all glyphs", "newComposites", "=", "new", "java", ".", "util", ".", "HashMap", "(", ")", ";", "Iterator", "e", "=", "glyphs", ".", "keySet", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "e", ".", "hasNext", "(", ")", ")", "{", "Integer", "origIndex", "=", "(", "Integer", ")", "e", ".", "next", "(", ")", ";", "if", "(", "in", ".", "readTTFShort", "(", "entry", ".", "getOffset", "(", ")", "+", "mtxTab", "[", "origIndex", ".", "intValue", "(", ")", "]", ".", "getOffset", "(", ")", ")", "<", "0", ")", "{", "// origIndex is a composite glyph", "allComposites", ".", "put", "(", "origIndex", ",", "glyphs", ".", "get", "(", "origIndex", ")", ")", ";", "List", "composites", "=", "getIncludedGlyphs", "(", "in", ",", "(", "int", ")", "entry", ".", "getOffset", "(", ")", ",", "origIndex", ")", ";", "// Iterate through all composites pointed to", "// by this composite and check if they exists", "// in the glyphs map, add them if not.", "Iterator", "cps", "=", "composites", ".", "iterator", "(", ")", ";", "while", "(", "cps", ".", "hasNext", "(", ")", ")", "{", "Integer", "cIdx", "=", "(", "Integer", ")", "cps", ".", "next", "(", ")", ";", "if", "(", "glyphs", ".", "get", "(", "cIdx", ")", "==", "null", "&&", "newComposites", ".", "get", "(", "cIdx", ")", "==", "null", ")", "{", "newComposites", ".", "put", "(", "cIdx", ",", "new", "Integer", "(", "newIndex", ")", ")", ";", "newIndex", "++", ";", "}", "}", "}", "}", "// Add composites to glyphs", "Iterator", "m", "=", "newComposites", ".", "keySet", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "m", ".", "hasNext", "(", ")", ")", "{", "Integer", "im", "=", "(", "Integer", ")", "m", ".", "next", "(", ")", ";", "glyphs", ".", "put", "(", "im", ",", "newComposites", ".", "get", "(", "im", ")", ")", ";", "}", "}", "// Iterate through all composites to remap their composite index", "Iterator", "ce", "=", "allComposites", ".", "keySet", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "ce", ".", "hasNext", "(", ")", ")", "{", "remapComposite", "(", "in", ",", "glyphs", ",", "(", "int", ")", "entry", ".", "getOffset", "(", ")", ",", "(", "Integer", ")", "ce", ".", "next", "(", ")", ")", ";", "}", "}", "else", "{", "throw", "new", "IOException", "(", "\"Can't find glyf table\"", ")", ";", "}", "}" ]

[ "Scan", "all", "the", "original", "glyphs", "for", "composite", "glyphs", "and", "add", "those", "glyphs", "to", "the", "glyphmapping", "also", "rewrite", "the", "composite", "glyph", "pointers", "to", "the", "new", "mapping" ]

[ "public", "byte", "[", "]", "readFont", "(", "FontFileReader", "in", ",", "String", "name", ",", "Map", "glyphs", ")", "throws", "IOException", "{", "//Check if TrueType collection, and that the name exists in the collection", "if", "(", "!", "checkTTC", "(", "in", ",", "name", ")", ")", "{", "throw", "new", "IOException", "(", "\"Failed to read font\"", ")", ";", "}", "output", "=", "new", "byte", "[", "in", ".", "getFileSize", "(", ")", "]", ";", "readDirTabs", "(", "in", ")", ";", "readFontHeader", "(", "in", ")", ";", "getNumGlyphs", "(", "in", ")", ";", "readHorizontalHeader", "(", "in", ")", ";", "readHorizontalMetrics", "(", "in", ")", ";", "readIndexToLocation", "(", "in", ")", ";", "scanGlyphs", "(", "in", ",", "glyphs", ")", ";", "createDirectory", "(", ")", ";", "// Create the TrueType header and directory", "createHead", "(", "in", ")", ";", "createHhea", "(", "in", ",", "glyphs", ".", "size", "(", ")", ")", ";", "// Create the hhea table", "createHmtx", "(", "in", ",", "glyphs", ")", ";", "// Create hmtx table", "createMaxp", "(", "in", ",", "glyphs", ".", "size", "(", ")", ")", ";", "// copy the maxp table", "try", "{", "createCvt", "(", "in", ")", ";", "// copy the cvt table", "}", "catch", "(", "IOException", "ex", ")", "{", "// Cvt is optional (only required for OpenType (MS) fonts)", "//log.error(\"TrueType warning: \" + ex.getMessage());", "}", "try", "{", "createFpgm", "(", "in", ")", ";", "// copy fpgm table", "}", "catch", "(", "IOException", "ex", ")", "{", "// Fpgm is optional (only required for OpenType (MS) fonts)", "//log.error(\"TrueType warning: \" + ex.getMessage());", "}", "try", "{", "createPrep", "(", "in", ")", ";", "// copy prep table", "}", "catch", "(", "IOException", "ex", ")", "{", "// Prep is optional (only required for OpenType (MS) fonts)", "//log.error(\"TrueType warning: \" + ex.getMessage());", "}", "try", "{", "createLoca", "(", "glyphs", ".", "size", "(", ")", ")", ";", "// create empty loca table", "}", "catch", "(", "IOException", "ex", ")", "{", "// Loca is optional (only required for OpenType (MS) fonts)", "//log.error(\"TrueType warning: \" + ex.getMessage());", "}", "try", "{", "createGlyf", "(", "in", ",", "glyphs", ")", ";", "}", "catch", "(", "IOException", "ex", ")", "{", "// Glyf is optional (only required for OpenType (MS) fonts)", "//log.error(\"TrueType warning: \" + ex.getMessage());", "}", "pad4", "(", ")", ";", "createCheckSumAdjustment", "(", ")", ";", "byte", "[", "]", "ret", "=", "new", "byte", "[", "realSize", "]", ";", "System", ".", "arraycopy", "(", "output", ",", "0", ",", "ret", ",", "0", ",", "realSize", ")", ";", "return", "ret", ";", "}" ]

[ "Returns", "a", "subset", "of", "the", "original", "font", "." ]

[ "private", "void", "writeUShort", "(", "int", "s", ")", "{", "byte", "b1", "=", "(", "byte", ")", "(", "(", "s", ">>", "8", ")", "&", "0xff", ")", ";", "byte", "b2", "=", "(", "byte", ")", "(", "s", "&", "0xff", ")", ";", "writeByte", "(", "b1", ")", ";", "writeByte", "(", "b2", ")", ";", "}" ]

[ "Appends", "a", "USHORT", "to", "the", "output", "array", "updates", "currentPost", "but", "not", "realSize" ]

[ "private", "void", "writeUShort", "(", "int", "pos", ",", "int", "s", ")", "{", "byte", "b1", "=", "(", "byte", ")", "(", "(", "s", ">>", "8", ")", "&", "0xff", ")", ";", "byte", "b2", "=", "(", "byte", ")", "(", "s", "&", "0xff", ")", ";", "output", "[", "pos", "]", "=", "b1", ";", "output", "[", "pos", "+", "1", "]", "=", "b2", ";", "}" ]

[ "Appends", "a", "USHORT", "to", "the", "output", "array", "at", "the", "given", "position", "without", "changing", "currentPos" ]

[ "private", "void", "writeULong", "(", "int", "s", ")", "{", "byte", "b1", "=", "(", "byte", ")", "(", "(", "s", ">>", "24", ")", "&", "0xff", ")", ";", "byte", "b2", "=", "(", "byte", ")", "(", "(", "s", ">>", "16", ")", "&", "0xff", ")", ";", "byte", "b3", "=", "(", "byte", ")", "(", "(", "s", ">>", "8", ")", "&", "0xff", ")", ";", "byte", "b4", "=", "(", "byte", ")", "(", "s", "&", "0xff", ")", ";", "writeByte", "(", "b1", ")", ";", "writeByte", "(", "b2", ")", ";", "writeByte", "(", "b3", ")", ";", "writeByte", "(", "b4", ")", ";", "}" ]

[ "Appends", "a", "ULONG", "to", "the", "output", "array", "updates", "currentPos", "but", "not", "realSize" ]

[ "private", "int", "readUShort", "(", "int", "pos", ")", "{", "int", "ret", "=", "output", "[", "pos", "]", ";", "if", "(", "ret", "<", "0", ")", "{", "ret", "+=", "256", ";", "}", "ret", "=", "ret", "<<", "8", ";", "if", "(", "output", "[", "pos", "+", "1", "]", "<", "0", ")", "{", "ret", "|=", "output", "[", "pos", "+", "1", "]", "+", "256", ";", "}", "else", "{", "ret", "|=", "output", "[", "pos", "+", "1", "]", ";", "}", "return", "ret", ";", "}" ]

[ "Read", "a", "unsigned", "short", "value", "at", "given", "position" ]

[ "private", "void", "pad4", "(", ")", "{", "int", "padSize", "=", "currentPos", "%", "4", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "padSize", ";", "i", "++", ")", "{", "output", "[", "currentPos", "++", "]", "=", "0", ";", "realSize", "++", ";", "}", "}" ]

[ "Create", "a", "padding", "in", "the", "fontfile", "to", "align", "on", "a", "4", "-", "byte", "boundary" ]

[ "private", "long", "getLongCheckSum", "(", "int", "start", ",", "int", "size", ")", "{", "// All the tables here are aligned on four byte boundaries", "// Add remainder to size if it's not a multiple of 4", "int", "remainder", "=", "size", "%", "4", ";", "if", "(", "remainder", "!=", "0", ")", "{", "size", "+=", "remainder", ";", "}", "long", "sum", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "size", ";", "i", "+=", "4", ")", "{", "int", "l", "=", "(", "output", "[", "start", "+", "i", "]", "<<", "24", ")", ";", "l", "+=", "(", "output", "[", "start", "+", "i", "+", "1", "]", "<<", "16", ")", ";", "l", "+=", "(", "output", "[", "start", "+", "i", "+", "2", "]", "<<", "16", ")", ";", "l", "+=", "(", "output", "[", "start", "+", "i", "+", "3", "]", "<<", "16", ")", ";", "sum", "+=", "l", ";", "if", "(", "sum", ">", "0xffffffff", ")", "{", "sum", "=", "sum", "-", "0xffffffff", ";", "}", "}", "return", "sum", ";", "}" ]

[ "Get", "the", "checksum", "as", "a", "long" ]

[ "public", "void", "setText", "(", "String", "value", ")", "{", "this", ".", "value", "=", "value", ";", "if", "(", "cursorPos", ">", "value", ".", "length", "(", ")", ")", "{", "cursorPos", "=", "value", ".", "length", "(", ")", ";", "}", "}" ]

[ "Set", "the", "value", "to", "be", "displayed", "in", "the", "text", "field" ]

[ "public", "void", "setCursorPos", "(", "int", "pos", ")", "{", "cursorPos", "=", "pos", ";", "if", "(", "cursorPos", ">", "value", ".", "length", "(", ")", ")", "{", "cursorPos", "=", "value", ".", "length", "(", ")", ";", "}", "}" ]

[ "Set", "the", "position", "of", "the", "cursor" ]

[ "public", "void", "setMaxLength", "(", "int", "length", ")", "{", "maxCharacter", "=", "length", ";", "if", "(", "value", ".", "length", "(", ")", ">", "maxCharacter", ")", "{", "value", "=", "value", ".", "substring", "(", "0", ",", "maxCharacter", ")", ";", "}", "}" ]

[ "Set", "the", "length", "of", "the", "allowed", "input" ]

[ "protected", "void", "doPaste", "(", "String", "text", ")", "{", "recordOldPosition", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "text", ".", "length", "(", ")", ";", "i", "++", ")", "{", "keyPressed", "(", "-", "1", ",", "text", ".", "charAt", "(", "i", ")", ")", ";", "}", "}" ]

[ "Do", "the", "paste", "into", "the", "field", "overrideable", "for", "custom", "behaviour" ]

[ "protected", "void", "doUndo", "(", "int", "oldCursorPos", ",", "String", "oldText", ")", "{", "if", "(", "oldText", "!=", "null", ")", "{", "setText", "(", "oldText", ")", ";", "setCursorPos", "(", "oldCursorPos", ")", ";", "}", "}" ]

[ "Do", "the", "undo", "of", "the", "paste", "overrideable", "for", "custom", "behaviour" ]

[ "public", "static", "FontData", "getPlain", "(", "String", "familyName", ")", "{", "FontData", "data", "=", "(", "FontData", ")", "plain", ".", "get", "(", "familyName", ")", ";", "return", "data", ";", "}" ]

[ "Get", "the", "plain", "version", "of", "a", "family", "name" ]

[ "public", "static", "FontData", "getBold", "(", "String", "familyName", ")", "{", "FontData", "data", "=", "(", "FontData", ")", "bold", ".", "get", "(", "familyName", ")", ";", "return", "data", ";", "}" ]

[ "Get", "the", "bold", "version", "of", "the", "font" ]

[ "public", "static", "FontData", "getBoldItalic", "(", "String", "familyName", ")", "{", "FontData", "data", "=", "(", "FontData", ")", "bolditalic", ".", "get", "(", "familyName", ")", ";", "return", "data", ";", "}" ]

[ "Get", "the", "bold", "italic", "version", "of", "the", "font" ]

[ "public", "static", "FontData", "getItalic", "(", "String", "familyName", ")", "{", "FontData", "data", "=", "(", "FontData", ")", "italic", ".", "get", "(", "familyName", ")", ";", "return", "data", ";", "}" ]

[ "Get", "the", "italic", "version", "of", "the", "font" ]

[ "public", "static", "FontData", "getStyled", "(", "String", "familyName", ",", "int", "style", ")", "{", "boolean", "b", "=", "(", "style", "&", "Font", ".", "BOLD", ")", "!=", "0", ";", "boolean", "i", "=", "(", "style", "&", "Font", ".", "ITALIC", ")", "!=", "0", ";", "if", "(", "b", "&", "i", ")", "{", "return", "getBoldItalic", "(", "familyName", ")", ";", "}", "else", "if", "(", "b", ")", "{", "return", "getBold", "(", "familyName", ")", ";", "}", "else", "if", "(", "i", ")", "{", "return", "getItalic", "(", "familyName", ")", ";", "}", "else", "{", "return", "getPlain", "(", "familyName", ")", ";", "}", "}" ]

[ "Get", "a", "styled", "version", "of", "a", "particular", "font", "family" ]

[ "private", "static", "void", "processFontDirectory", "(", "File", "dir", ",", "ArrayList", "fonts", ")", "{", "if", "(", "!", "dir", ".", "exists", "(", ")", ")", "{", "return", ";", "}", "if", "(", "processed", ".", "contains", "(", "dir", ")", ")", "{", "return", ";", "}", "processed", ".", "add", "(", "dir", ")", ";", "File", "[", "]", "sources", "=", "dir", ".", "listFiles", "(", ")", ";", "if", "(", "sources", "==", "null", ")", "{", "return", ";", "}", "for", "(", "int", "j", "=", "0", ";", "j", "<", "sources", ".", "length", ";", "j", "++", ")", "{", "File", "source", "=", "sources", "[", "j", "]", ";", "if", "(", "source", ".", "getName", "(", ")", ".", "equals", "(", "\".\"", ")", ")", "{", "continue", ";", "}", "if", "(", "source", ".", "getName", "(", ")", ".", "equals", "(", "\"..\"", ")", ")", "{", "continue", ";", "}", "if", "(", "source", ".", "isDirectory", "(", ")", ")", "{", "processFontDirectory", "(", "source", ",", "fonts", ")", ";", "continue", ";", "}", "if", "(", "source", ".", "getName", "(", ")", ".", "toLowerCase", "(", ")", ".", "endsWith", "(", "\".ttf\"", ")", ")", "{", "try", "{", "if", "(", "statusListener", "!=", "null", ")", "{", "statusListener", ".", "updateStatus", "(", "\"Processing \"", "+", "source", ".", "getName", "(", ")", ")", ";", "}", "FontData", "data", "=", "new", "FontData", "(", "new", "FileInputStream", "(", "source", ")", ",", "1", ")", ";", "fonts", ".", "add", "(", "data", ")", ";", "String", "famName", "=", "data", ".", "getFamilyName", "(", ")", ";", "if", "(", "!", "families", ".", "contains", "(", "famName", ")", ")", "{", "families", ".", "add", "(", "famName", ")", ";", "}", "boolean", "bo", "=", "data", ".", "getJavaFont", "(", ")", ".", "isBold", "(", ")", ";", "boolean", "it", "=", "data", ".", "getJavaFont", "(", ")", ".", "isItalic", "(", ")", ";", "if", "(", "(", "bo", ")", "&&", "(", "it", ")", ")", "{", "bolditalic", ".", "put", "(", "famName", ",", "data", ")", ";", "}", "else", "if", "(", "bo", ")", "{", "bold", ".", "put", "(", "famName", ",", "data", ")", ";", "}", "else", "if", "(", "it", ")", "{", "italic", ".", "put", "(", "famName", ",", "data", ")", ";", "}", "else", "{", "plain", ".", "put", "(", "famName", ",", "data", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "if", "(", "DEBUG", ")", "{", "System", ".", "err", ".", "println", "(", "\"Unable to process: \"", "+", "source", ".", "getAbsolutePath", "(", ")", "+", "\" (\"", "+", "e", ".", "getClass", "(", ")", "+", "\": \"", "+", "e", ".", "getMessage", "(", ")", "+", "\")\"", ")", ";", "}", "if", "(", "statusListener", "!=", "null", ")", "{", "statusListener", ".", "updateStatus", "(", "\"Unable to process: \"", "+", "source", ".", "getName", "(", ")", ")", ";", "}", "}", "}", "}", "}" ]

[ "Process", "a", "directory", "potentially", "full", "of", "fonts" ]

[ "public", "static", "FontData", "[", "]", "getAllFonts", "(", ")", "{", "if", "(", "fonts", "==", "null", ")", "{", "fonts", "=", "new", "ArrayList", "(", ")", ";", "String", "os", "=", "System", ".", "getProperty", "(", "\"os.name\"", ")", ";", "File", "[", "]", "locs", "=", "new", "File", "[", "0", "]", ";", "if", "(", "os", ".", "startsWith", "(", "\"Windows\"", ")", ")", "{", "locs", "=", "win32", ";", "}", "if", "(", "os", ".", "startsWith", "(", "\"Linux\"", ")", ")", "{", "locs", "=", "linux", ";", "}", "if", "(", "os", ".", "startsWith", "(", "\"Mac OS\"", ")", ")", "{", "locs", "=", "macos", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "locs", ".", "length", ";", "i", "++", ")", "{", "File", "loc", "=", "locs", "[", "i", "]", ";", "processFontDirectory", "(", "loc", ",", "fonts", ")", ";", "}", "if", "(", "os", ".", "startsWith", "(", "\"Linux\"", ")", ")", "{", "locateLinuxFonts", "(", "new", "File", "(", "\"/etc/fonts/fonts.conf\"", ")", ")", ";", "}", "}", "return", "(", "FontData", "[", "]", ")", "fonts", ".", "toArray", "(", "new", "FontData", "[", "0", "]", ")", ";", "}" ]

[ "Get", "all", "the", "fonts", "available" ]

[ "private", "static", "void", "locateLinuxFonts", "(", "File", "file", ")", "{", "if", "(", "!", "file", ".", "exists", "(", ")", ")", "{", "System", ".", "err", ".", "println", "(", "\"Unable to open: \"", "+", "file", ".", "getAbsolutePath", "(", ")", ")", ";", "return", ";", "}", "try", "{", "InputStream", "in", "=", "new", "FileInputStream", "(", "file", ")", ";", "BufferedReader", "reader", "=", "new", "BufferedReader", "(", "new", "InputStreamReader", "(", "in", ")", ")", ";", "ByteArrayOutputStream", "temp", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "PrintStream", "pout", "=", "new", "PrintStream", "(", "temp", ")", ";", "while", "(", "reader", ".", "ready", "(", ")", ")", "{", "String", "line", "=", "reader", ".", "readLine", "(", ")", ";", "if", "(", "line", ".", "indexOf", "(", "\"DOCTYPE\"", ")", "==", "-", "1", ")", "{", "pout", ".", "println", "(", "line", ")", ";", "}", "}", "in", "=", "new", "ByteArrayInputStream", "(", "temp", ".", "toByteArray", "(", ")", ")", ";", "DocumentBuilderFactory", "factory", "=", "DocumentBuilderFactory", ".", "newInstance", "(", ")", ";", "DocumentBuilder", "builder", "=", "factory", ".", "newDocumentBuilder", "(", ")", ";", "Document", "document", "=", "builder", ".", "parse", "(", "in", ")", ";", "NodeList", "dirs", "=", "document", ".", "getElementsByTagName", "(", "\"dir\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "dirs", ".", "getLength", "(", ")", ";", "i", "++", ")", "{", "Element", "element", "=", "(", "Element", ")", "dirs", ".", "item", "(", "i", ")", ";", "String", "dir", "=", "element", ".", "getFirstChild", "(", ")", ".", "getNodeValue", "(", ")", ";", "if", "(", "dir", ".", "startsWith", "(", "\"~\"", ")", ")", "{", "dir", "=", "dir", ".", "substring", "(", "1", ")", ";", "dir", "=", "userhome", "+", "dir", ";", "}", "addFontDirectory", "(", "new", "File", "(", "dir", ")", ")", ";", "}", "NodeList", "includes", "=", "document", ".", "getElementsByTagName", "(", "\"include\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "includes", ".", "getLength", "(", ")", ";", "i", "++", ")", "{", "Element", "element", "=", "(", "Element", ")", "dirs", ".", "item", "(", "i", ")", ";", "String", "inc", "=", "element", ".", "getFirstChild", "(", ")", ".", "getNodeValue", "(", ")", ";", "if", "(", "inc", ".", "startsWith", "(", "\"~\"", ")", ")", "{", "inc", "=", "inc", ".", "substring", "(", "1", ")", ";", "inc", "=", "userhome", "+", "inc", ";", "}", "locateLinuxFonts", "(", "new", "File", "(", "inc", ")", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "System", ".", "err", ".", "println", "(", "\"Unable to process: \"", "+", "file", ".", "getAbsolutePath", "(", ")", ")", ";", "}", "}" ]

[ "Locate", "the", "linux", "fonts", "based", "on", "the", "XML", "configuration", "file" ]

[ "public", "FontData", "deriveFont", "(", "float", "size", ",", "int", "style", ")", "{", "FontData", "original", "=", "getStyled", "(", "getFamilyName", "(", ")", ",", "style", ")", ";", "FontData", "data", "=", "new", "FontData", "(", ")", ";", "data", ".", "size", "=", "size", ";", "data", ".", "javaFont", "=", "original", ".", "javaFont", ".", "deriveFont", "(", "style", ",", "size", ")", ";", "data", ".", "upem", "=", "upem", ";", "data", ".", "ansiKerning", "=", "ansiKerning", ";", "data", ".", "charWidth", "=", "charWidth", ";", "return", "data", ";", "}" ]

[ "Derive", "a", "new", "version", "of", "this", "font", "based", "on", "a", "new", "size" ]

[ "public", "int", "getKerning", "(", "char", "first", ",", "char", "second", ")", "{", "Map", "toMap", "=", "(", "Map", ")", "ansiKerning", ".", "get", "(", "new", "Integer", "(", "first", ")", ")", ";", "if", "(", "toMap", "==", "null", ")", "{", "return", "0", ";", "}", "Integer", "kerning", "=", "(", "Integer", ")", "toMap", ".", "get", "(", "new", "Integer", "(", "second", ")", ")", ";", "if", "(", "kerning", "==", "null", ")", "{", "return", "0", ";", "}", "return", "Math", ".", "round", "(", "convertUnitToEm", "(", "size", ",", "kerning", ".", "intValue", "(", ")", ")", ")", ";", "}" ]

[ "Get", "the", "kerning", "value", "between", "two", "characters" ]

[ "private", "static", "void", "checkProperty", "(", ")", "{", "if", "(", "!", "pngLoaderPropertyChecked", ")", "{", "pngLoaderPropertyChecked", "=", "true", ";", "try", "{", "AccessController", ".", "doPrivileged", "(", "new", "PrivilegedAction", "(", ")", "{", "public", "Object", "run", "(", ")", "{", "String", "val", "=", "System", ".", "getProperty", "(", "PNG_LOADER", ")", ";", "if", "(", "\"false\"", ".", "equalsIgnoreCase", "(", "val", ")", ")", "{", "usePngLoader", "=", "false", ";", "}", "Log", ".", "info", "(", "\"Use Java PNG Loader = \"", "+", "usePngLoader", ")", ";", "return", "null", ";", "}", "}", ")", ";", "}", "catch", "(", "Throwable", "e", ")", "{", "// ignore, security failure - probably an applet\r", "}", "}", "}" ]

[ "Check", "PNG", "loader", "property", ".", "If", "set", "the", "native", "PNG", "loader", "will", "not", "be", "used", "." ]

[ "public", "static", "LoadableImageData", "getImageDataFor", "(", "String", "ref", ")", "{", "LoadableImageData", "imageData", ";", "checkProperty", "(", ")", ";", "ref", "=", "ref", ".", "toLowerCase", "(", ")", ";", "if", "(", "ref", ".", "endsWith", "(", "\".tga\"", ")", ")", "{", "return", "new", "TGAImageData", "(", ")", ";", "}", "if", "(", "ref", ".", "endsWith", "(", "\".png\"", ")", ")", "{", "CompositeImageData", "data", "=", "new", "CompositeImageData", "(", ")", ";", "if", "(", "usePngLoader", ")", "{", "data", ".", "add", "(", "new", "PNGImageData", "(", ")", ")", ";", "}", "data", ".", "add", "(", "new", "ImageIOImageData", "(", ")", ")", ";", "return", "data", ";", "}", "return", "new", "ImageIOImageData", "(", ")", ";", "}" ]

[ "Create", "an", "image", "data", "that", "is", "appropriate", "for", "the", "reference", "supplied" ]

[ "public", "String", "read", "(", "FontFileReader", "in", ")", "throws", "IOException", "{", "tag", "[", "0", "]", "=", "in", ".", "readTTFByte", "(", ")", ";", "tag", "[", "1", "]", "=", "in", ".", "readTTFByte", "(", ")", ";", "tag", "[", "2", "]", "=", "in", ".", "readTTFByte", "(", ")", ";", "tag", "[", "3", "]", "=", "in", ".", "readTTFByte", "(", ")", ";", "in", ".", "skip", "(", "4", ")", ";", "// Skip checksum", "offset", "=", "in", ".", "readTTFULong", "(", ")", ";", "length", "=", "in", ".", "readTTFULong", "(", ")", ";", "String", "tagStr", "=", "new", "String", "(", "tag", ",", "\"ISO-8859-1\"", ")", ";", "return", "tagStr", ";", "}" ]

[ "Read", "Dir", "Tab", "return", "tag", "name" ]

[ "private", "void", "addEnableControl", "(", "String", "text", ",", "ItemListener", "listener", ")", "{", "JCheckBox", "enableControl", "=", "new", "JCheckBox", "(", "\"Enable \"", "+", "text", ")", ";", "enableControl", ".", "setBounds", "(", "10", ",", "offset", ",", "200", ",", "20", ")", ";", "enableControl", ".", "addItemListener", "(", "listener", ")", ";", "add", "(", "enableControl", ")", ";", "controlToValueName", ".", "put", "(", "enableControl", ",", "text", ")", ";", "valueNameToControl", ".", "put", "(", "text", ",", "enableControl", ")", ";", "offset", "+=", "25", ";", "}" ]

[ "Add", "a", "control", "for", "enablement" ]

[ "public", "void", "itemStateChangedHandler", "(", "ItemEvent", "e", ")", "{", "String", "valueName", "=", "(", "String", ")", "controlToValueName", ".", "get", "(", "e", ".", "getSource", "(", ")", ")", ";", "LinearInterpolator", "value", "=", "(", "LinearInterpolator", ")", "valueMap", ".", "get", "(", "valueName", ")", ";", "if", "(", "e", ".", "getStateChange", "(", ")", "==", "ItemEvent", ".", "SELECTED", ")", "{", "value", ".", "setActive", "(", "true", ")", ";", "editor", ".", "registerValue", "(", "value", ",", "valueName", ")", ";", "}", "else", "{", "value", ".", "setActive", "(", "false", ")", ";", "editor", ".", "removeValue", "(", "valueName", ")", ";", "}", "}" ]

[ "Notificaiton", "that", "one", "of", "the", "configuration", "option", "has", "changed", "state" ]

[ "private", "void", "linkToEmitter", "(", "String", "name", ",", "LinearInterpolator", "interpol", ")", "{", "// put to value map\r", "valueMap", ".", "put", "(", "name", ",", "interpol", ")", ";", "// now update the checkbox to represent the state of the given\r", "// interpolator\r", "boolean", "checked", "=", "interpol", ".", "isActive", "(", ")", ";", "JCheckBox", "enableControl", "=", "(", "JCheckBox", ")", "valueNameToControl", ".", "get", "(", "name", ")", ";", "enableControl", ".", "setSelected", "(", "false", ")", ";", "if", "(", "checked", ")", "enableControl", ".", "setSelected", "(", "checked", ")", ";", "}" ]

[ "Link", "this", "set", "of", "controls", "to", "a", "linear", "interpolater", "within", "the", "particle", "emitter" ]

[ "private", "void", "blur", "(", "BufferedImage", "image", ")", "{", "float", "[", "]", "matrix", "=", "GAUSSIAN_BLUR_KERNELS", "[", "blurKernelSize", "-", "1", "]", ";", "Kernel", "gaussianBlur1", "=", "new", "Kernel", "(", "matrix", ".", "length", ",", "1", ",", "matrix", ")", ";", "Kernel", "gaussianBlur2", "=", "new", "Kernel", "(", "1", ",", "matrix", ".", "length", ",", "matrix", ")", ";", "RenderingHints", "hints", "=", "new", "RenderingHints", "(", "RenderingHints", ".", "KEY_RENDERING", ",", "RenderingHints", ".", "VALUE_RENDER_SPEED", ")", ";", "ConvolveOp", "gaussianOp1", "=", "new", "ConvolveOp", "(", "gaussianBlur1", ",", "ConvolveOp", ".", "EDGE_NO_OP", ",", "hints", ")", ";", "ConvolveOp", "gaussianOp2", "=", "new", "ConvolveOp", "(", "gaussianBlur2", ",", "ConvolveOp", ".", "EDGE_NO_OP", ",", "hints", ")", ";", "BufferedImage", "scratchImage", "=", "EffectUtil", ".", "getScratchImage", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "blurPasses", ";", "i", "++", ")", "{", "gaussianOp1", ".", "filter", "(", "image", ",", "scratchImage", ")", ";", "gaussianOp2", ".", "filter", "(", "scratchImage", ",", "image", ")", ";", "}", "}" ]

[ "Apply", "blurring", "to", "the", "generate", "image" ]

[ "public", "Texture", "getTexture", "(", "File", "source", ",", "boolean", "flipped", ",", "int", "filter", ")", "throws", "IOException", "{", "String", "resourceName", "=", "source", ".", "getAbsolutePath", "(", ")", ";", "InputStream", "in", "=", "new", "FileInputStream", "(", "source", ")", ";", "return", "getTexture", "(", "in", ",", "resourceName", ",", "flipped", ",", "filter", ",", "null", ")", ";", "}" ]

[ "Get", "a", "texture", "from", "a", "specific", "file" ]

[ "public", "Texture", "getTexture", "(", "String", "resourceName", ",", "boolean", "flipped", ",", "int", "filter", ")", "throws", "IOException", "{", "InputStream", "in", "=", "ResourceLoader", ".", "getResourceAsStream", "(", "resourceName", ")", ";", "return", "getTexture", "(", "in", ",", "resourceName", ",", "flipped", ",", "filter", ",", "null", ")", ";", "}" ]

[ "Get", "a", "texture", "from", "a", "resource", "location" ]

[ "public", "void", "reload", "(", ")", "{", "Iterator", "texs", "=", "texturesLinear", ".", "values", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "texs", ".", "hasNext", "(", ")", ")", "{", "(", "(", "TextureImpl", ")", "texs", ".", "next", "(", ")", ")", ".", "reload", "(", ")", ";", "}", "texs", "=", "texturesNearest", ".", "values", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "texs", ".", "hasNext", "(", ")", ")", "{", "(", "(", "TextureImpl", ")", "texs", ".", "next", "(", ")", ")", ".", "reload", "(", ")", ";", "}", "}" ]

[ "Reload", "all", "the", "textures", "loaded", "in", "this", "loader" ]

[ "public", "int", "reload", "(", "TextureImpl", "texture", ",", "int", "srcPixelFormat", ",", "int", "componentCount", ",", "int", "minFilter", ",", "int", "magFilter", ",", "ByteBuffer", "textureBuffer", ")", "{", "int", "target", "=", "SGL", ".", "GL_TEXTURE_2D", ";", "int", "textureID", "=", "createTextureID", "(", ")", ";", "GL", ".", "glBindTexture", "(", "target", ",", "textureID", ")", ";", "GL", ".", "glTexParameteri", "(", "target", ",", "SGL", ".", "GL_TEXTURE_MIN_FILTER", ",", "minFilter", ")", ";", "GL", ".", "glTexParameteri", "(", "target", ",", "SGL", ".", "GL_TEXTURE_MAG_FILTER", ",", "magFilter", ")", ";", "// produce a texture from the byte buffer\r", "GL", ".", "glTexImage2D", "(", "target", ",", "0", ",", "dstPixelFormat", ",", "texture", ".", "getTextureWidth", "(", ")", ",", "texture", ".", "getTextureHeight", "(", ")", ",", "0", ",", "srcPixelFormat", ",", "SGL", ".", "GL_UNSIGNED_BYTE", ",", "textureBuffer", ")", ";", "return", "textureID", ";", "}" ]

[ "Reload", "a", "given", "texture", "blob" ]

[ "public", "Image", "getSprite", "(", "String", "name", ")", "{", "Section", "section", "=", "(", "Section", ")", "sections", ".", "get", "(", "name", ")", ";", "if", "(", "section", "==", "null", ")", "{", "throw", "new", "RuntimeException", "(", "\"Unknown sprite from packed sheet: \"", "+", "name", ")", ";", "}", "return", "image", ".", "getSubImage", "(", "section", ".", "x", ",", "section", ".", "y", ",", "section", ".", "width", ",", "section", ".", "height", ")", ";", "}" ]

[ "Get", "a", "single", "named", "sprite", "from", "the", "sheet" ]

[ "public", "SpriteSheet", "getSpriteSheet", "(", "String", "name", ")", "{", "Image", "image", "=", "getSprite", "(", "name", ")", ";", "Section", "section", "=", "(", "Section", ")", "sections", ".", "get", "(", "name", ")", ";", "return", "new", "SpriteSheet", "(", "image", ",", "section", ".", "width", "/", "section", ".", "tilesx", ",", "section", ".", "height", "/", "section", ".", "tilesy", ")", ";", "}" ]

[ "Get", "a", "sprite", "sheet", "that", "has", "been", "packed", "into", "the", "greater", "image" ]

[ "private", "void", "loadDefinition", "(", "String", "def", ",", "Color", "trans", ")", "throws", "SlickException", "{", "BufferedReader", "reader", "=", "new", "BufferedReader", "(", "new", "InputStreamReader", "(", "ResourceLoader", ".", "getResourceAsStream", "(", "def", ")", ")", ")", ";", "try", "{", "image", "=", "new", "Image", "(", "basePath", "+", "reader", ".", "readLine", "(", ")", ",", "false", ",", "filter", ",", "trans", ")", ";", "while", "(", "reader", ".", "ready", "(", ")", ")", "{", "if", "(", "reader", ".", "readLine", "(", ")", "==", "null", ")", "{", "break", ";", "}", "Section", "sect", "=", "new", "Section", "(", "reader", ")", ";", "sections", ".", "put", "(", "sect", ".", "name", ",", "sect", ")", ";", "if", "(", "reader", ".", "readLine", "(", ")", "==", "null", ")", "{", "break", ";", "}", "}", "}", "catch", "(", "Exception", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "throw", "new", "SlickException", "(", "\"Failed to process definitions file - invalid format?\"", ",", "e", ")", ";", "}", "}" ]

[ "Load", "the", "definition", "file", "and", "parse", "each", "of", "the", "sections" ]

[ "public", "void", "reset", "(", ")", "{", "while", "(", "holes", "!=", "null", ")", "{", "holes", "=", "freePointBag", "(", "holes", ")", ";", "}", "contour", ".", "clear", "(", ")", ";", "holes", "=", "null", ";", "}" ]

[ "Reset", "the", "internal", "state", "of", "the", "triangulator" ]

[ "private", "void", "addPoint", "(", "Vector2f", "pt", ")", "{", "if", "(", "holes", "==", "null", ")", "{", "Point", "p", "=", "getPoint", "(", "pt", ")", ";", "contour", ".", "add", "(", "p", ")", ";", "}", "else", "{", "Point", "p", "=", "getPoint", "(", "pt", ")", ";", "holes", ".", "add", "(", "p", ")", ";", "}", "}" ]

[ "Add", "a", "defined", "point", "to", "the", "current", "contour" ]

[ "private", "PointBag", "freePointBag", "(", "PointBag", "pb", ")", "{", "PointBag", "next", "=", "pb", ".", "next", ";", "pb", ".", "clear", "(", ")", ";", "pb", ".", "next", "=", "nextFreePointBag", ";", "nextFreePointBag", "=", "pb", ";", "return", "next", ";", "}" ]

[ "Release", "a", "pooled", "bag" ]

[ "private", "Point", "getPoint", "(", "Vector2f", "pt", ")", "{", "Point", "p", "=", "nextFreePoint", ";", "if", "(", "p", "!=", "null", ")", "{", "nextFreePoint", "=", "p", ".", "next", ";", "// initialize new point to safe values\r", "p", ".", "next", "=", "null", ";", "p", ".", "prev", "=", "null", ";", "p", ".", "pt", "=", "pt", ";", "return", "p", ";", "}", "return", "new", "Point", "(", "pt", ")", ";", "}" ]

[ "Create", "or", "reuse", "a", "point" ]

[ "private", "void", "freePoints", "(", "Point", "head", ")", "{", "head", ".", "prev", ".", "next", "=", "nextFreePoint", ";", "head", ".", "prev", "=", "null", ";", "nextFreePoint", "=", "head", ";", "}" ]

[ "Release", "all", "points" ]

[ "private", "void", "initStreams", "(", ")", "throws", "IOException", "{", "if", "(", "audio", "!=", "null", ")", "{", "audio", ".", "close", "(", ")", ";", "}", "OggInputStream", "audio", ";", "if", "(", "url", "!=", "null", ")", "{", "audio", "=", "new", "OggInputStream", "(", "url", ".", "openStream", "(", ")", ")", ";", "}", "else", "{", "audio", "=", "new", "OggInputStream", "(", "ResourceLoader", ".", "getResourceAsStream", "(", "ref", ")", ")", ";", "}", "this", ".", "audio", "=", "audio", ";", "positionOffset", "=", "0", ";", "}" ]

[ "Initialise", "our", "connection", "to", "the", "underlying", "resource" ]

[ "public", "void", "play", "(", "boolean", "loop", ")", "throws", "IOException", "{", "this", ".", "loop", "=", "loop", ";", "initStreams", "(", ")", ";", "done", "=", "false", ";", "AL10", ".", "alSourceStop", "(", "source", ")", ";", "removeBuffers", "(", ")", ";", "startPlayback", "(", ")", ";", "}" ]

[ "Start", "this", "stream", "playing" ]

[ "public", "boolean", "stream", "(", "int", "bufferId", ")", "{", "try", "{", "int", "count", "=", "audio", ".", "read", "(", "buffer", ")", ";", "if", "(", "count", "!=", "-", "1", ")", "{", "bufferData", ".", "clear", "(", ")", ";", "bufferData", ".", "put", "(", "buffer", ",", "0", ",", "count", ")", ";", "bufferData", ".", "flip", "(", ")", ";", "int", "format", "=", "audio", ".", "getChannels", "(", ")", ">", "1", "?", "AL10", ".", "AL_FORMAT_STEREO16", ":", "AL10", ".", "AL_FORMAT_MONO16", ";", "try", "{", "AL10", ".", "alBufferData", "(", "bufferId", ",", "format", ",", "bufferData", ",", "audio", ".", "getRate", "(", ")", ")", ";", "}", "catch", "(", "OpenALException", "e", ")", "{", "Log", ".", "error", "(", "\"Failed to loop buffer: \"", "+", "bufferId", "+", "\" \"", "+", "format", "+", "\" \"", "+", "count", "+", "\" \"", "+", "audio", ".", "getRate", "(", ")", ",", "e", ")", ";", "return", "false", ";", "}", "}", "else", "{", "if", "(", "loop", ")", "{", "initStreams", "(", ")", ";", "stream", "(", "bufferId", ")", ";", "}", "else", "{", "done", "=", "true", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}", "catch", "(", "IOException", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "return", "false", ";", "}", "}" ]

[ "Stream", "some", "data", "from", "the", "audio", "stream", "to", "the", "buffer", "indicates", "by", "the", "ID" ]

[ "public", "boolean", "setPosition", "(", "float", "position", ")", "{", "try", "{", "if", "(", "getPosition", "(", ")", ">", "position", ")", "{", "initStreams", "(", ")", ";", "}", "float", "sampleRate", "=", "audio", ".", "getRate", "(", ")", ";", "float", "sampleSize", ";", "if", "(", "audio", ".", "getChannels", "(", ")", ">", "1", ")", "{", "sampleSize", "=", "4", ";", "// AL10.AL_FORMAT_STEREO16\r", "}", "else", "{", "sampleSize", "=", "2", ";", "// AL10.AL_FORMAT_MONO16\r", "}", "while", "(", "positionOffset", "<", "position", ")", "{", "int", "count", "=", "audio", ".", "read", "(", "buffer", ")", ";", "if", "(", "count", "!=", "-", "1", ")", "{", "float", "bufferLength", "=", "(", "count", "/", "sampleSize", ")", "/", "sampleRate", ";", "positionOffset", "+=", "bufferLength", ";", "}", "else", "{", "if", "(", "loop", ")", "{", "initStreams", "(", ")", ";", "}", "else", "{", "done", "=", "true", ";", "}", "return", "false", ";", "}", "}", "startPlayback", "(", ")", ";", "return", "true", ";", "}", "catch", "(", "IOException", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "return", "false", ";", "}", "}" ]

[ "Seeks", "to", "a", "position", "in", "the", "music", "." ]

[ "private", "void", "startPlayback", "(", ")", "{", "AL10", ".", "alSourcei", "(", "source", ",", "AL10", ".", "AL_LOOPING", ",", "AL10", ".", "AL_FALSE", ")", ";", "AL10", ".", "alSourcef", "(", "source", ",", "AL10", ".", "AL_PITCH", ",", "pitch", ")", ";", "remainingBufferCount", "=", "BUFFER_COUNT", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "BUFFER_COUNT", ";", "i", "++", ")", "{", "stream", "(", "bufferNames", ".", "get", "(", "i", ")", ")", ";", "}", "AL10", ".", "alSourceQueueBuffers", "(", "source", ",", "bufferNames", ")", ";", "AL10", ".", "alSourcePlay", "(", "source", ")", ";", "}" ]

[ "Starts", "the", "streaming", "." ]

[ "public", "void", "reset", "(", ")", "{", "Iterator", "pools", "=", "particlesByEmitter", ".", "values", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "pools", ".", "hasNext", "(", ")", ")", "{", "ParticlePool", "pool", "=", "(", "ParticlePool", ")", "pools", ".", "next", "(", ")", ";", "pool", ".", "reset", "(", "this", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "emitters", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ParticleEmitter", "emitter", "=", "(", "ParticleEmitter", ")", "emitters", ".", "get", "(", "i", ")", ";", "emitter", ".", "resetState", "(", ")", ";", "}", "}" ]

[ "Reset", "the", "state", "of", "the", "system" ]

[ "public", "void", "addEmitter", "(", "ParticleEmitter", "emitter", ")", "{", "emitters", ".", "add", "(", "emitter", ")", ";", "ParticlePool", "pool", "=", "new", "ParticlePool", "(", "this", ",", "maxParticlesPerEmitter", ")", ";", "particlesByEmitter", ".", "put", "(", "emitter", ",", "pool", ")", ";", "}" ]

[ "Add", "a", "particle", "emitter", "to", "be", "used", "on", "this", "system" ]

[ "public", "void", "removeAllEmitters", "(", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "emitters", ".", "size", "(", ")", ";", "i", "++", ")", "{", "removeEmitter", "(", "(", "ParticleEmitter", ")", "emitters", ".", "get", "(", "i", ")", ")", ";", "i", "--", ";", "}", "}" ]

[ "Remove", "all", "the", "emitters", "from", "the", "system" ]

[ "public", "void", "render", "(", "float", "x", ",", "float", "y", ")", "{", "if", "(", "(", "sprite", "==", "null", ")", "&&", "(", "defaultImageName", "!=", "null", ")", ")", "{", "loadSystemParticleImage", "(", ")", ";", "}", "if", "(", "!", "visible", ")", "{", "return", ";", "}", "GL", ".", "glTranslatef", "(", "x", ",", "y", ",", "0", ")", ";", "if", "(", "blendingMode", "==", "BLEND_ADDITIVE", ")", "{", "GL", ".", "glBlendFunc", "(", "SGL", ".", "GL_SRC_ALPHA", ",", "SGL", ".", "GL_ONE", ")", ";", "}", "if", "(", "usePoints", "(", ")", ")", "{", "GL", ".", "glEnable", "(", "SGL", ".", "GL_POINT_SMOOTH", ")", ";", "TextureImpl", ".", "bindNone", "(", ")", ";", "}", "// iterate over all emitters\r", "for", "(", "int", "emitterIdx", "=", "0", ";", "emitterIdx", "<", "emitters", ".", "size", "(", ")", ";", "emitterIdx", "++", ")", "{", "// get emitter\r", "ParticleEmitter", "emitter", "=", "(", "ParticleEmitter", ")", "emitters", ".", "get", "(", "emitterIdx", ")", ";", "if", "(", "!", "emitter", ".", "isEnabled", "(", ")", ")", "{", "continue", ";", "}", "// check for additive override and enable when set\r", "if", "(", "emitter", ".", "useAdditive", "(", ")", ")", "{", "GL", ".", "glBlendFunc", "(", "SGL", ".", "GL_SRC_ALPHA", ",", "SGL", ".", "GL_ONE", ")", ";", "}", "// now get the particle pool for this emitter and render all particles that are in use\r", "ParticlePool", "pool", "=", "(", "ParticlePool", ")", "particlesByEmitter", ".", "get", "(", "emitter", ")", ";", "Image", "image", "=", "emitter", ".", "getImage", "(", ")", ";", "if", "(", "image", "==", "null", ")", "{", "image", "=", "this", ".", "sprite", ";", "}", "if", "(", "!", "emitter", ".", "isOriented", "(", ")", "&&", "!", "emitter", ".", "usePoints", "(", "this", ")", ")", "{", "image", ".", "startUse", "(", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "pool", ".", "particles", ".", "length", ";", "i", "++", ")", "{", "if", "(", "pool", ".", "particles", "[", "i", "]", ".", "inUse", "(", ")", ")", "pool", ".", "particles", "[", "i", "]", ".", "render", "(", ")", ";", "}", "if", "(", "!", "emitter", ".", "isOriented", "(", ")", "&&", "!", "emitter", ".", "usePoints", "(", "this", ")", ")", "{", "image", ".", "endUse", "(", ")", ";", "}", "// reset additive blend mode\r", "if", "(", "emitter", ".", "useAdditive", "(", ")", ")", "{", "GL", ".", "glBlendFunc", "(", "SGL", ".", "GL_SRC_ALPHA", ",", "SGL", ".", "GL_ONE_MINUS_SRC_ALPHA", ")", ";", "}", "}", "if", "(", "usePoints", "(", ")", ")", "{", "GL", ".", "glDisable", "(", "SGL", ".", "GL_POINT_SMOOTH", ")", ";", "}", "if", "(", "blendingMode", "==", "BLEND_ADDITIVE", ")", "{", "GL", ".", "glBlendFunc", "(", "SGL", ".", "GL_SRC_ALPHA", ",", "SGL", ".", "GL_ONE_MINUS_SRC_ALPHA", ")", ";", "}", "Color", ".", "white", ".", "bind", "(", ")", ";", "GL", ".", "glTranslatef", "(", "-", "x", ",", "-", "y", ",", "0", ")", ";", "}" ]

[ "Render", "the", "particles", "in", "the", "system" ]

[ "private", "void", "loadSystemParticleImage", "(", ")", "{", "AccessController", ".", "doPrivileged", "(", "new", "PrivilegedAction", "(", ")", "{", "public", "Object", "run", "(", ")", "{", "try", "{", "if", "(", "mask", "!=", "null", ")", "{", "sprite", "=", "new", "Image", "(", "defaultImageName", ",", "mask", ")", ";", "}", "else", "{", "sprite", "=", "new", "Image", "(", "defaultImageName", ")", ";", "}", "}", "catch", "(", "SlickException", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "defaultImageName", "=", "null", ";", "}", "return", "null", ";", "// nothing to return\r", "}", "}", ")", ";", "}" ]

[ "Load", "the", "system", "particle", "image", "as", "the", "extension", "permissions" ]

[ "public", "void", "update", "(", "int", "delta", ")", "{", "if", "(", "(", "sprite", "==", "null", ")", "&&", "(", "defaultImageName", "!=", "null", ")", ")", "{", "loadSystemParticleImage", "(", ")", ";", "}", "removeMe", ".", "clear", "(", ")", ";", "ArrayList", "emitters", "=", "new", "ArrayList", "(", "this", ".", "emitters", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "emitters", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ParticleEmitter", "emitter", "=", "(", "ParticleEmitter", ")", "emitters", ".", "get", "(", "i", ")", ";", "if", "(", "emitter", ".", "isEnabled", "(", ")", ")", "{", "emitter", ".", "update", "(", "this", ",", "delta", ")", ";", "if", "(", "removeCompletedEmitters", ")", "{", "if", "(", "emitter", ".", "completed", "(", ")", ")", "{", "removeMe", ".", "add", "(", "emitter", ")", ";", "particlesByEmitter", ".", "remove", "(", "emitter", ")", ";", "}", "}", "}", "}", "this", ".", "emitters", ".", "removeAll", "(", "removeMe", ")", ";", "pCount", "=", "0", ";", "if", "(", "!", "particlesByEmitter", ".", "isEmpty", "(", ")", ")", "{", "Iterator", "it", "=", "particlesByEmitter", ".", "keySet", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "it", ".", "hasNext", "(", ")", ")", "{", "ParticleEmitter", "emitter", "=", "(", "ParticleEmitter", ")", "it", ".", "next", "(", ")", ";", "if", "(", "emitter", ".", "isEnabled", "(", ")", ")", "{", "ParticlePool", "pool", "=", "(", "ParticlePool", ")", "particlesByEmitter", ".", "get", "(", "emitter", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "pool", ".", "particles", ".", "length", ";", "i", "++", ")", "{", "if", "(", "pool", ".", "particles", "[", "i", "]", ".", "life", ">", "0", ")", "{", "pool", ".", "particles", "[", "i", "]", ".", "update", "(", "delta", ")", ";", "pCount", "++", ";", "}", "}", "}", "}", "}", "}" ]

[ "Update", "the", "system", "request", "the", "assigned", "emitters", "update", "the", "particles" ]

[ "public", "Particle", "getNewParticle", "(", "ParticleEmitter", "emitter", ",", "float", "life", ")", "{", "ParticlePool", "pool", "=", "(", "ParticlePool", ")", "particlesByEmitter", ".", "get", "(", "emitter", ")", ";", "ArrayList", "available", "=", "pool", ".", "available", ";", "if", "(", "available", ".", "size", "(", ")", ">", "0", ")", "{", "Particle", "p", "=", "(", "Particle", ")", "available", ".", "remove", "(", "available", ".", "size", "(", ")", "-", "1", ")", ";", "p", ".", "init", "(", "emitter", ",", "life", ")", ";", "p", ".", "setImage", "(", "sprite", ")", ";", "return", "p", ";", "}", "Log", ".", "warn", "(", "\"Ran out of particles (increase the limit)!\"", ")", ";", "return", "dummy", ";", "}" ]

[ "Get", "a", "new", "particle", "from", "the", "system", ".", "This", "should", "be", "used", "by", "emitters", "to", "request", "particles" ]

[ "public", "void", "release", "(", "Particle", "particle", ")", "{", "if", "(", "particle", "!=", "dummy", ")", "{", "ParticlePool", "pool", "=", "(", "ParticlePool", ")", "particlesByEmitter", ".", "get", "(", "particle", ".", "getEmitter", "(", ")", ")", ";", "pool", ".", "available", ".", "add", "(", "particle", ")", ";", "}", "}" ]

[ "Release", "a", "particle", "back", "to", "the", "system", "once", "it", "has", "expired" ]

[ "public", "void", "releaseAll", "(", "ParticleEmitter", "emitter", ")", "{", "if", "(", "!", "particlesByEmitter", ".", "isEmpty", "(", ")", ")", "{", "Iterator", "it", "=", "particlesByEmitter", ".", "values", "(", ")", ".", "iterator", "(", ")", ";", "while", "(", "it", ".", "hasNext", "(", ")", ")", "{", "ParticlePool", "pool", "=", "(", "ParticlePool", ")", "it", ".", "next", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "pool", ".", "particles", ".", "length", ";", "i", "++", ")", "{", "if", "(", "pool", ".", "particles", "[", "i", "]", ".", "inUse", "(", ")", ")", "{", "if", "(", "pool", ".", "particles", "[", "i", "]", ".", "getEmitter", "(", ")", "==", "emitter", ")", "{", "pool", ".", "particles", "[", "i", "]", ".", "setLife", "(", "-", "1", ")", ";", "release", "(", "pool", ".", "particles", "[", "i", "]", ")", ";", "}", "}", "}", "}", "}", "}" ]

[ "Release", "all", "the", "particles", "owned", "by", "the", "specified", "emitter" ]

[ "public", "void", "moveAll", "(", "ParticleEmitter", "emitter", ",", "float", "x", ",", "float", "y", ")", "{", "ParticlePool", "pool", "=", "(", "ParticlePool", ")", "particlesByEmitter", ".", "get", "(", "emitter", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "pool", ".", "particles", ".", "length", ";", "i", "++", ")", "{", "if", "(", "pool", ".", "particles", "[", "i", "]", ".", "inUse", "(", ")", ")", "{", "pool", ".", "particles", "[", "i", "]", ".", "move", "(", "x", ",", "y", ")", ";", "}", "}", "}" ]

[ "Move", "all", "the", "particles", "owned", "by", "the", "specified", "emitter" ]

[ "public", "ParticleSystem", "duplicate", "(", ")", "throws", "SlickException", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "emitters", ".", "size", "(", ")", ";", "i", "++", ")", "{", "if", "(", "!", "(", "emitters", ".", "get", "(", "i", ")", "instanceof", "ConfigurableEmitter", ")", ")", "{", "throw", "new", "SlickException", "(", "\"Only systems contianing configurable emitters can be duplicated\"", ")", ";", "}", "}", "ParticleSystem", "theCopy", "=", "null", ";", "try", "{", "ByteArrayOutputStream", "bout", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "ParticleIO", ".", "saveConfiguredSystem", "(", "bout", ",", "this", ")", ";", "ByteArrayInputStream", "bin", "=", "new", "ByteArrayInputStream", "(", "bout", ".", "toByteArray", "(", ")", ")", ";", "theCopy", "=", "ParticleIO", ".", "loadConfiguredSystem", "(", "bin", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "Log", ".", "error", "(", "\"Failed to duplicate particle system\"", ")", ";", "throw", "new", "SlickException", "(", "\"Unable to duplicated particle system\"", ",", "e", ")", ";", "}", "return", "theCopy", ";", "}" ]

[ "Create", "a", "duplicate", "of", "this", "system", ".", "This", "would", "have", "been", "nicer", "as", "a", "different", "interface", "but", "may", "cause", "to", "much", "API", "change", "headache", ".", "Maybe", "next", "full", "version", "release", "it", "should", "be", "rethought", "." ]

[ "public", "static", "void", "setRenderer", "(", "int", "type", ")", "{", "switch", "(", "type", ")", "{", "case", "IMMEDIATE_RENDERER", ":", "setRenderer", "(", "new", "ImmediateModeOGLRenderer", "(", ")", ")", ";", "return", ";", "case", "VERTEX_ARRAY_RENDERER", ":", "setRenderer", "(", "new", "VAOGLRenderer", "(", ")", ")", ";", "return", ";", "}", "throw", "new", "RuntimeException", "(", "\"Unknown renderer type: \"", "+", "type", ")", ";", "}" ]

[ "Set", "the", "renderer", "to", "one", "of", "the", "known", "types" ]

[ "public", "static", "void", "setLineStripRenderer", "(", "int", "type", ")", "{", "switch", "(", "type", ")", "{", "case", "DEFAULT_LINE_STRIP_RENDERER", ":", "setLineStripRenderer", "(", "new", "DefaultLineStripRenderer", "(", ")", ")", ";", "return", ";", "case", "QUAD_BASED_LINE_STRIP_RENDERER", ":", "setLineStripRenderer", "(", "new", "QuadBasedLineStripRenderer", "(", ")", ")", ";", "return", ";", "}", "throw", "new", "RuntimeException", "(", "\"Unknown line strip renderer type: \"", "+", "type", ")", ";", "}" ]

[ "Set", "the", "line", "strip", "renderer", "to", "one", "of", "the", "known", "types" ]

[ "public", "void", "transform", "(", "float", "source", "[", "]", ",", "int", "sourceOffset", ",", "float", "destination", "[", "]", ",", "int", "destOffset", ",", "int", "numberOfPoints", ")", "{", "//TODO performance can be improved by removing the safety to the destination array \r", "float", "result", "[", "]", "=", "source", "==", "destination", "?", "new", "float", "[", "numberOfPoints", "*", "2", "]", ":", "destination", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numberOfPoints", "*", "2", ";", "i", "+=", "2", ")", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "6", ";", "j", "+=", "3", ")", "{", "result", "[", "i", "+", "(", "j", "/", "3", ")", "]", "=", "source", "[", "i", "+", "sourceOffset", "]", "*", "matrixPosition", "[", "j", "]", "+", "source", "[", "i", "+", "sourceOffset", "+", "1", "]", "*", "matrixPosition", "[", "j", "+", "1", "]", "+", "1", "*", "matrixPosition", "[", "j", "+", "2", "]", ";", "}", "}", "if", "(", "source", "==", "destination", ")", "{", "//for safety of the destination, the results are copied after the entire operation. \r", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numberOfPoints", "*", "2", ";", "i", "+=", "2", ")", "{", "destination", "[", "i", "+", "destOffset", "]", "=", "result", "[", "i", "]", ";", "destination", "[", "i", "+", "destOffset", "+", "1", "]", "=", "result", "[", "i", "+", "1", "]", ";", "}", "}", "}" ]

[ "Transform", "the", "point", "pairs", "in", "the", "source", "array", "and", "store", "them", "in", "the", "destination", "array", ".", "All", "operations", "will", "be", "done", "before", "storing", "the", "results", "in", "the", "destination", ".", "This", "way", "the", "source", "and", "destination", "array", "can", "be", "the", "same", "without", "worry", "of", "overwriting", "information", "before", "it", "is", "transformed", "." ]

[ "public", "Transform", "concatenate", "(", "Transform", "tx", ")", "{", "float", "[", "]", "mp", "=", "new", "float", "[", "9", "]", ";", "float", "n00", "=", "matrixPosition", "[", "0", "]", "*", "tx", ".", "matrixPosition", "[", "0", "]", "+", "matrixPosition", "[", "1", "]", "*", "tx", ".", "matrixPosition", "[", "3", "]", ";", "float", "n01", "=", "matrixPosition", "[", "0", "]", "*", "tx", ".", "matrixPosition", "[", "1", "]", "+", "matrixPosition", "[", "1", "]", "*", "tx", ".", "matrixPosition", "[", "4", "]", ";", "float", "n02", "=", "matrixPosition", "[", "0", "]", "*", "tx", ".", "matrixPosition", "[", "2", "]", "+", "matrixPosition", "[", "1", "]", "*", "tx", ".", "matrixPosition", "[", "5", "]", "+", "matrixPosition", "[", "2", "]", ";", "float", "n10", "=", "matrixPosition", "[", "3", "]", "*", "tx", ".", "matrixPosition", "[", "0", "]", "+", "matrixPosition", "[", "4", "]", "*", "tx", ".", "matrixPosition", "[", "3", "]", ";", "float", "n11", "=", "matrixPosition", "[", "3", "]", "*", "tx", ".", "matrixPosition", "[", "1", "]", "+", "matrixPosition", "[", "4", "]", "*", "tx", ".", "matrixPosition", "[", "4", "]", ";", "float", "n12", "=", "matrixPosition", "[", "3", "]", "*", "tx", ".", "matrixPosition", "[", "2", "]", "+", "matrixPosition", "[", "4", "]", "*", "tx", ".", "matrixPosition", "[", "5", "]", "+", "matrixPosition", "[", "5", "]", ";", "mp", "[", "0", "]", "=", "n00", ";", "mp", "[", "1", "]", "=", "n01", ";", "mp", "[", "2", "]", "=", "n02", ";", "mp", "[", "3", "]", "=", "n10", ";", "mp", "[", "4", "]", "=", "n11", ";", "mp", "[", "5", "]", "=", "n12", ";", "// \t\r", "// mp[0] = matrixPosition[0] * transform.matrixPosition[0] + matrixPosition[0] * transform.matrixPosition[3] + matrixPosition[0] * transform.matrixPosition[6]; \r", "// mp[1] = matrixPosition[1] * transform.matrixPosition[1] + matrixPosition[1] * transform.matrixPosition[4] + matrixPosition[1] * transform.matrixPosition[7];\r", "// mp[2] = matrixPosition[2] * transform.matrixPosition[2] + matrixPosition[2] * transform.matrixPosition[5] + matrixPosition[2] * transform.matrixPosition[8]; \r", "// mp[3] = matrixPosition[3] * transform.matrixPosition[0] + matrixPosition[3] * transform.matrixPosition[3] + matrixPosition[3] * transform.matrixPosition[6]; \r", "// mp[4] = matrixPosition[4] * transform.matrixPosition[1] + matrixPosition[4] * transform.matrixPosition[4] + matrixPosition[4] * transform.matrixPosition[7];\r", "// mp[5] = matrixPosition[5] * transform.matrixPosition[2] + matrixPosition[5] * transform.matrixPosition[5] + matrixPosition[5] * transform.matrixPosition[8]; \r", "// \r", "matrixPosition", "=", "mp", ";", "return", "this", ";", "}" ]

[ "Update", "this", "Transform", "by", "concatenating", "the", "given", "Transform", "to", "this", "one", "." ]

[ "public", "static", "Transform", "createRotateTransform", "(", "float", "angle", ")", "{", "return", "new", "Transform", "(", "(", "float", ")", "FastTrig", ".", "cos", "(", "angle", ")", ",", "-", "(", "float", ")", "FastTrig", ".", "sin", "(", "angle", ")", ",", "0", ",", "(", "float", ")", "FastTrig", ".", "sin", "(", "angle", ")", ",", "(", "float", ")", "FastTrig", ".", "cos", "(", "angle", ")", ",", "0", ")", ";", "}" ]

[ "Create", "a", "new", "rotation", "Transform" ]