--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.desktop/macosx/classes/sun/font/CCharToGlyphMapper.java Sun Aug 17 15:54:13 2014 +0100
@@ -0,0 +1,328 @@
+/*
+ * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.font;
+
+import java.util.HashMap;
+
+public class CCharToGlyphMapper extends CharToGlyphMapper {
+ private static native int countGlyphs(final long nativeFontPtr);
+
+ private Cache cache = new Cache();
+ CFont fFont;
+ int numGlyphs = -1;
+
+ public CCharToGlyphMapper(CFont font) {
+ fFont = font;
+ missingGlyph = 0; // for getMissingGlyphCode()
+ }
+
+ public int getNumGlyphs() {
+ if (numGlyphs == -1) {
+ numGlyphs = countGlyphs(fFont.getNativeFontPtr());
+ }
+ return numGlyphs;
+ }
+
+ public boolean canDisplay(char ch) {
+ int glyph = charToGlyph(ch);
+ return glyph != missingGlyph;
+ }
+
+ public boolean canDisplay(int cp) {
+ int glyph = charToGlyph(cp);
+ return glyph != missingGlyph;
+ }
+
+ public synchronized boolean charsToGlyphsNS(int count,
+ char[] unicodes, int[] glyphs)
+ {
+ charsToGlyphs(count, unicodes, glyphs);
+
+ // The following shaping checks are from either
+ // TrueTypeGlyphMapper or Type1GlyphMapper
+ for (int i = 0; i < count; i++) {
+ int code = unicodes[i];
+
+ if (code >= HI_SURROGATE_START && code <= HI_SURROGATE_END && i < count - 1) {
+ char low = unicodes[i + 1];
+
+ if (low >= LO_SURROGATE_START && low <= LO_SURROGATE_END) {
+ code = (code - HI_SURROGATE_START) * 0x400 + low - LO_SURROGATE_START + 0x10000;
+ glyphs[i + 1] = INVISIBLE_GLYPH_ID;
+ }
+ }
+
+ if (code < 0x0590) {
+ continue;
+ } else if (code <= 0x05ff) {
+ // Hebrew 0x0590->0x05ff
+ return true;
+ } else if (code >= 0x0600 && code <= 0x06ff) {
+ // Arabic
+ return true;
+ } else if (code >= 0x0900 && code <= 0x0d7f) {
+ // if Indic, assume shaping for conjuncts, reordering:
+ // 0900 - 097F Devanagari
+ // 0980 - 09FF Bengali
+ // 0A00 - 0A7F Gurmukhi
+ // 0A80 - 0AFF Gujarati
+ // 0B00 - 0B7F Oriya
+ // 0B80 - 0BFF Tamil
+ // 0C00 - 0C7F Telugu
+ // 0C80 - 0CFF Kannada
+ // 0D00 - 0D7F Malayalam
+ return true;
+ } else if (code >= 0x0e00 && code <= 0x0e7f) {
+ // if Thai, assume shaping for vowel, tone marks
+ return true;
+ } else if (code >= 0x200c && code <= 0x200d) {
+ // zwj or zwnj
+ return true;
+ } else if (code >= 0x202a && code <= 0x202e) {
+ // directional control
+ return true;
+ } else if (code >= 0x206a && code <= 0x206f) {
+ // directional control
+ return true;
+ } else if (code >= 0x10000) {
+ i += 1; // Empty glyph slot after surrogate
+ continue;
+ }
+ }
+
+ return false;
+ }
+
+ public synchronized int charToGlyph(char unicode) {
+ final int glyph = cache.get(unicode);
+ if (glyph != 0) return glyph;
+
+ final char[] unicodeArray = new char[] { unicode };
+ final int[] glyphArray = new int[1];
+
+ nativeCharsToGlyphs(fFont.getNativeFontPtr(), 1, unicodeArray, glyphArray);
+ cache.put(unicode, glyphArray[0]);
+
+ return glyphArray[0];
+ }
+
+ public synchronized int charToGlyph(int unicode) {
+ if (unicode >= 0x10000) {
+ int[] glyphs = new int[2];
+ char[] surrogates = new char[2];
+ int base = unicode - 0x10000;
+ surrogates[0] = (char)((base >>> 10) + HI_SURROGATE_START);
+ surrogates[1] = (char)((base % 0x400) + LO_SURROGATE_START);
+ charsToGlyphs(2, surrogates, glyphs);
+ return glyphs[0];
+ } else {
+ return charToGlyph((char)unicode);
+ }
+ }
+
+ public synchronized void charsToGlyphs(int count, char[] unicodes, int[] glyphs) {
+ cache.get(count, unicodes, glyphs);
+ }
+
+ public synchronized void charsToGlyphs(int count, int[] unicodes, int[] glyphs) {
+ for (int i = 0; i < count; i++) {
+ glyphs[i] = charToGlyph(unicodes[i]);
+ };
+ }
+
+ // This mapper returns either the glyph code, or if the character can be
+ // replaced on-the-fly using CoreText substitution; the negative unicode
+ // value. If this "glyph code int" is treated as an opaque code, it will
+ // strike and measure exactly as a real glyph code - whether the character
+ // is present or not. Missing characters for any font on the system will
+ // be returned as 0, as the getMissingGlyphCode() function above indicates.
+ private static native void nativeCharsToGlyphs(final long nativeFontPtr,
+ int count, char[] unicodes,
+ int[] glyphs);
+
+ private class Cache {
+ private static final int FIRST_LAYER_SIZE = 256;
+ private static final int SECOND_LAYER_SIZE = 16384; // 16384 = 128x128
+
+ private final int[] firstLayerCache = new int[FIRST_LAYER_SIZE];
+ private SparseBitShiftingTwoLayerArray secondLayerCache;
+ private HashMap<Integer, Integer> generalCache;
+
+ Cache() {
+ // <rdar://problem/5331678> need to prevent getting '-1' stuck in the cache
+ firstLayerCache[1] = 1;
+ }
+
+ public synchronized int get(final int index) {
+ if (index < FIRST_LAYER_SIZE) {
+ // catch common glyphcodes
+ return firstLayerCache[index];
+ }
+
+ if (index < SECOND_LAYER_SIZE) {
+ // catch common unicodes
+ if (secondLayerCache == null) return 0;
+ return secondLayerCache.get(index);
+ }
+
+ if (generalCache == null) return 0;
+ final Integer value = generalCache.get(index);
+ if (value == null) return 0;
+ return value.intValue();
+ }
+
+ public synchronized void put(final int index, final int value) {
+ if (index < FIRST_LAYER_SIZE) {
+ // catch common glyphcodes
+ firstLayerCache[index] = value;
+ return;
+ }
+
+ if (index < SECOND_LAYER_SIZE) {
+ // catch common unicodes
+ if (secondLayerCache == null) {
+ secondLayerCache = new SparseBitShiftingTwoLayerArray(SECOND_LAYER_SIZE, 7); // 128x128
+ }
+ secondLayerCache.put(index, value);
+ return;
+ }
+
+ if (generalCache == null) {
+ generalCache = new HashMap<Integer, Integer>();
+ }
+
+ generalCache.put(index, value);
+ }
+
+ private class SparseBitShiftingTwoLayerArray {
+ final int[][] cache;
+ final int shift;
+ final int secondLayerLength;
+
+ public SparseBitShiftingTwoLayerArray(final int size,
+ final int shift)
+ {
+ this.shift = shift;
+ this.cache = new int[1 << shift][];
+ this.secondLayerLength = size >> shift;
+ }
+
+ public int get(final int index) {
+ final int firstIndex = index >> shift;
+ final int[] firstLayerRow = cache[firstIndex];
+ if (firstLayerRow == null) return 0;
+ return firstLayerRow[index - (firstIndex * (1 << shift))];
+ }
+
+ public void put(final int index, final int value) {
+ final int firstIndex = index >> shift;
+ int[] firstLayerRow = cache[firstIndex];
+ if (firstLayerRow == null) {
+ cache[firstIndex] = firstLayerRow = new int[secondLayerLength];
+ }
+ firstLayerRow[index - (firstIndex * (1 << shift))] = value;
+ }
+ }
+
+ public synchronized void get(int count, char[] indicies, int[] values)
+ {
+ // "missed" is the count of 'char' that are not mapped.
+ // Surrogates count for 2.
+ // unmappedChars is the unique list of these chars.
+ // unmappedCharIndices is the location in the original array
+ int missed = 0;
+ char[] unmappedChars = null;
+ int [] unmappedCharIndices = null;
+
+ for (int i = 0; i < count; i++){
+ int code = indicies[i];
+ if (code >= HI_SURROGATE_START &&
+ code <= HI_SURROGATE_END && i < count - 1)
+ {
+ char low = indicies[i + 1];
+ if (low >= LO_SURROGATE_START && low <= LO_SURROGATE_END) {
+ code = (code - HI_SURROGATE_START) * 0x400 +
+ low - LO_SURROGATE_START + 0x10000;
+ }
+ }
+
+ final int value = get(code);
+ if (value != 0 && value != -1) {
+ values[i] = value;
+ if (code >= 0x10000) {
+ values[i+1] = INVISIBLE_GLYPH_ID;
+ i++;
+ }
+ } else {
+ values[i] = 0;
+ put(code, -1);
+ if (unmappedChars == null) {
+ // This is likely to be longer than we need,
+ // but is the simplest and cheapest option.
+ unmappedChars = new char[indicies.length];
+ unmappedCharIndices = new int[indicies.length];
+ }
+ unmappedChars[missed] = indicies[i];
+ unmappedCharIndices[missed] = i;
+ if (code >= 0x10000) { // was a surrogate pair
+ unmappedChars[++missed] = indicies[++i];
+ }
+ missed++;
+ }
+ }
+
+ if (missed == 0) {
+ return;
+ }
+
+ final int[] glyphCodes = new int[missed];
+
+ // bulk call to fill in the unmapped code points.
+ nativeCharsToGlyphs(fFont.getNativeFontPtr(),
+ missed, unmappedChars, glyphCodes);
+
+ for (int m = 0; m < missed; m++){
+ int i = unmappedCharIndices[m];
+ int code = unmappedChars[m];
+ if (code >= HI_SURROGATE_START &&
+ code <= HI_SURROGATE_END && m < missed - 1)
+ {
+ char low = indicies[m + 1];
+ if (low >= LO_SURROGATE_START && low <= LO_SURROGATE_END) {
+ code = (code - HI_SURROGATE_START) * 0x400 +
+ low - LO_SURROGATE_START + 0x10000;
+ }
+ }
+ values[i] = glyphCodes[m];
+ put(code, values[i]);
+ if (code >= 0x10000) {
+ m++;
+ values[i + 1] = INVISIBLE_GLYPH_ID;
+ }
+ }
+ }
+ }
+}