/*
* This file is modified by Ivan Maidanski <ivmai@ivmaisoft.com>
* Project name: JCGO-SUNAWT (http://www.ivmaisoft.com/jcgo/)
*/
/*
* A cache of latin-1, kana, and cjk advances, to speed up TextLayout metrics operations.
*
* @(#)AdvanceCache.java 1.4 02/10/09
*/
package sun.awt.font;
import java.awt.Font;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.font.LineMetrics;
import java.awt.geom.Rectangle2D;
import java.lang.ref.SoftReference;
public final class AdvanceCache {
private Font font;
private FontRenderContext frc;
private LineMetrics lineMetrics;
private float[] latinAdvances;
private float[] kanaAdvances; // hira, kana almost always monospaced, but just in case
private float cjkAdvance;
private float cjkFullAdvance; // probably redundant with cjkAdvance, but might have a bad composite font
private float cjkHalfAdvance;
private float[] latin1GlyphInfo; // redundant with advances, but advances are quicker to index?
private float[] kanaGlyphInfo;
private float[] missingGlyphInfo;
private float missingGlyphAdvance;
private static final char KANA_MIN = '\u3040';
private static final char KANA_LIM = '\u3100';
private static final char CJK_SAMPLE1 = '\u4e9e';
private static final char CJK_SAMPLE2 = '\u4e9a';
private static final char CJK_SAMPLE3 = '\u4e9c';
private static final char CJK_MIN = '\u3200';
private static final char CJK_LIM = '\u9fb0';
private static final char CJKFULL_SAMPLE = '\uff01';
private static final char CJKFULL1_MIN = '\uff00';
private static final char CJKFULL1_LIM = '\uff5f';
private static final char CJKFULL2_MIN = '\uffe0';
private static final char CJKFULL2_LIM = '\uffe7';
private static final char CJKHALF_SAMPLE = '\uff61';
private static final char CJKHALF_MIN = '\uff61';
private static final char CJKHALF_LIM = '\uff9e';
// not used
private static final char KSYL_SAMPLE = '\uac00';
private static final char KSYL_MIN = '\uac00';
private static final char KSYL_MAX = '\ud7a0';
private static final Object cacheLock = new Object();
private static final int CACHE_SIZE = 30;
private static SoftReference[] cache = new SoftReference[CACHE_SIZE];
private static int cacheNum;
private static boolean enabled = true;
private static String latin1;
private static String kana;
static {
char[] chars = new char[0x100];
for (int i = 0; i < chars.length; ++i) {
chars[i] = (char)i;
}
// these aren't rendered by textlayout, but are by drawstring...
chars[9] = chars[0xa] = chars[0xd] = ' ';
latin1 = new String(chars);
int kanaLen = KANA_LIM - KANA_MIN;
chars = new char[kanaLen + 5];
for (int i = 0; i < kanaLen; ++i) {
chars[i] = (char)(KANA_MIN + i);
}
chars[kanaLen] = CJK_SAMPLE1;
chars[kanaLen+1] = CJKFULL_SAMPLE;
chars[kanaLen+2] = CJKHALF_SAMPLE;
chars[kanaLen+3] = CJK_SAMPLE2;
chars[kanaLen+4] = CJK_SAMPLE3;
kana = new String(chars);
try {
String useCache = System.getProperty("sun.awt.font.advancecache");
if (useCache != null && useCache.equals("off")) {
enabled = false;
}
} catch(SecurityException e) {
}
}
private boolean equals(Font font, FontRenderContext frc) {
return this.font.equals(font) && this.frc.equals(frc);
}
/**
* Return true if the advance cache supports queries on the indicated text.
* This implies also that no special layout is required.
*/
public static boolean supportsText(char[] chars, int start, int limit) {
if (!enabled) return false;
for (int i = start; i < limit; ++i) {
char c = chars[i];
if (!((c < 0x100) ||
(c >= KANA_MIN && c < KANA_LIM) ||
(c >= CJK_MIN && c < CJK_LIM) ||
(c >= CJKHALF_MIN && c < CJKHALF_LIM) ||
(c >= CJKFULL1_MIN && c < CJKFULL1_LIM) ||
(c >= CJKFULL2_MIN && c < CJKFULL2_LIM))) {
return false;
}
}
return true;
}
public static boolean supportsText(char[] chars) {
return supportsText(chars, 0, chars.length);
}
static int statCount = 0;
static int statTest = 0;
static int statMiss = 0;
static int statFlush = 0;
static int statFlushDelta = 0;
static int statLastFlushCount = 0;
public static AdvanceCache get(Font font, FontRenderContext frc) {
if (!enabled) return null;
synchronized (cacheLock) {
++statCount;
int i = 0;
while (i < cacheNum) {
AdvanceCache ac = (AdvanceCache)cache[i].get();
if (ac == null) {
// gc flushed our cache, assume all empty
++statFlush;
statFlushDelta = statCount - statLastFlushCount;
statLastFlushCount = statCount;
cache = new SoftReference[CACHE_SIZE]; // reset to initial size
cacheNum = 0;
break;
} else {
++statTest;
if (ac.equals(font, frc)) {
if (i > 0) {
SoftReference ref = cache[i];
while (i > 0) {
cache[i] = cache[--i];
}
cache[0] = ref;
}
return ac;
}
++i;
}
}
++statMiss;
if (i == cache.length) { // cache is full, so grow cache (maybe just use a large cache?)
SoftReference[] ncache = new SoftReference[cache.length + CACHE_SIZE]; // linear growth, gc should control it
System.arraycopy(cache, 0, ncache, 1, cache.length);
cache = ncache;
} else {
while (--i >= 0) {
cache[i+1] = cache[i];
}
}
AdvanceCache ac = new AdvanceCache(font, frc);
cache[0] = new SoftReference(ac);
++cacheNum;
return ac;
}
}
private void initLatinAdvances() {
StandardGlyphVector sgv = new StandardGlyphVector(font, latin1, frc);
latin1GlyphInfo = sgv.getGlyphInfo();
latinAdvances = new float[256];
for (int i = 0, n = 0; i < latinAdvances.length; ++i, n += 8) {
latinAdvances[i] = latin1GlyphInfo[n+2];
latin1GlyphInfo[n+4] -= latin1GlyphInfo[n]; // normalize visual bounds to position
latin1GlyphInfo[n+6] += latin1GlyphInfo[n+4]; // width -> right
latin1GlyphInfo[n+7] += latin1GlyphInfo[n+5]; // height -> bottom
}
// these aren't rendered by textlayout
// earlier mapping to spaces ensures glyph info width/height is empty
// we don't use glyphInfo advances so this is ok
latinAdvances[9] = latinAdvances[0xa] = latinAdvances[0xd] = 0;
}
private void initKanaAdvances() {
StandardGlyphVector sgv = new StandardGlyphVector(font, kana, frc);
kanaGlyphInfo = sgv.getGlyphInfo();
int missingGlyph = font.getMissingGlyphCode();
kanaAdvances = new float[kana.length()];
for (int i = 0, n = 0; i < kanaAdvances.length; ++i, n += 8) {
kanaAdvances[i] = kanaGlyphInfo[n+2];
kanaGlyphInfo[n+4] -= kanaGlyphInfo[n]; // normalize visual bounds to position
kanaGlyphInfo[n+6] += kanaGlyphInfo[n+4]; // width -> right
kanaGlyphInfo[n+7] += kanaGlyphInfo[n+5]; // height -> bottom
}
// init other cjk here
int kanaLen = KANA_LIM - KANA_MIN;
int cjkIndex = kanaLen;
if (sgv.getGlyphCode(kanaLen) == missingGlyph) {
if (sgv.getGlyphCode(kanaLen+3) != missingGlyph) {
cjkIndex = kanaLen+3;
} else if (sgv.getGlyphCode(kanaLen+4) != missingGlyph) {
cjkIndex = kanaLen+4;
}
}
cjkAdvance = kanaAdvances[cjkIndex];
if (cjkIndex != kanaLen) {
System.arraycopy(kanaGlyphInfo, cjkIndex * 8, kanaGlyphInfo, kanaLen * 8, 8);
}
cjkFullAdvance = kanaAdvances[kanaLen + 1];
cjkHalfAdvance = kanaAdvances[kanaLen + 2];
}
private void initMissingGlyphInfo() {
int[] glyphIDs = { font.getMissingGlyphCode() };
StandardGlyphVector sgv = new StandardGlyphVector(font, glyphIDs, frc);
missingGlyphInfo = sgv.getGlyphInfo();
missingGlyphInfo[4] -= missingGlyphInfo[0]; // normalize visual bounds to position
missingGlyphInfo[6] += missingGlyphInfo[4]; // width -> right
missingGlyphInfo[7] += missingGlyphInfo[5]; // height -> bottom
missingGlyphAdvance = missingGlyphInfo[2];
}
private AdvanceCache(Font font, FontRenderContext frc) {
this.font = font;
this.frc = frc;
initLatinAdvances();
// defer init of kana advances?
initKanaAdvances();
initMissingGlyphInfo();
// sigh, just assume ASCII metrics
// or perhaps remove metrics API altogether
this.lineMetrics = font.getLineMetrics(latin1, frc);
}
public LineMetrics getLineMetrics() {
return lineMetrics;
}
public float getAdvance(char c) {
if (c < 0x100) { // this check doesn't slow down ASCII significantly
return latinAdvances[c];
} else if (c >= KANA_MIN && c < KANA_LIM) {
return kanaAdvances[c - KANA_MIN];
} else if (c >= CJK_MIN && c < CJK_LIM) {
return font.canDisplay(c) ? cjkAdvance : missingGlyphAdvance;
} else if (c >= CJKHALF_MIN && c < CJKHALF_LIM) {
return font.canDisplay(c) ? cjkHalfAdvance : missingGlyphAdvance;
} else if (c >= CJKFULL1_MIN && c < CJKFULL1_LIM) {
return font.canDisplay(c) ? cjkFullAdvance : missingGlyphAdvance;
} else if (c >= CJKFULL2_MIN && c < CJKFULL2_LIM) {
return font.canDisplay(c) ? cjkFullAdvance : missingGlyphAdvance;
} else {
// throw same error as if we'd just looked up in a table
throw new IndexOutOfBoundsException("no advance for char " + Integer.toHexString(c));
}
}
public float getAdvance(String str) {
return getAdvance(str.toCharArray());
}
public float getAdvance(char[] chars) {
return getAdvance(chars, 0, chars.length);
}
public float getAdvance(char[] chars, int start, int limit) {
float adv = 0;
for (int i = start; i < limit; ++i) {
//adv += getAdvance(chars[i]); // this adds 5-10% to the time
char c = chars[i];
if (c < 0x100) { // this check doesn't slow down ASCII significantly
adv += latinAdvances[c];
} else if (c >= KANA_MIN && c < KANA_LIM) {
adv += kanaAdvances[c - KANA_MIN];
} else if (c >= CJK_MIN && c < CJK_LIM) {
adv += font.canDisplay(c) ? cjkAdvance : missingGlyphAdvance;
} else if (c >= CJKHALF_MIN && c < CJKHALF_LIM) {
adv += font.canDisplay(c) ? cjkHalfAdvance : missingGlyphAdvance;
} else if (c >= CJKFULL1_MIN && c < CJKFULL1_LIM) {
adv += font.canDisplay(c) ? cjkFullAdvance : missingGlyphAdvance;
} else if (c >= CJKFULL2_MIN && c < CJKFULL2_LIM) {
adv += font.canDisplay(c) ? cjkFullAdvance : missingGlyphAdvance;
} else {
// throw same error as if we'd just looked up in a table
throw new IndexOutOfBoundsException("no advance for char " + Integer.toHexString(c));
}
}
return adv;
}
public Rectangle2D getLogicalBounds(String str) {
return getLogicalBounds(str.toCharArray());
}
public Rectangle2D getLogicalBounds(char[] chars) {
return getLogicalBounds(chars, 0, chars.length);
}
public Rectangle2D getLogicalBounds(char[] chars, int start, int limit) {
float adv = getAdvance(chars, start, limit);
return new Rectangle2D.Float(0,
-lineMetrics.getAscent(),
adv,
lineMetrics.getHeight());
}
public Rectangle2D getVisualBounds(String str) {
return getVisualBounds(str.toCharArray());
}
public Rectangle2D getVisualBounds(char[] chars) {
return getVisualBounds(chars, 0, chars.length);
}
public Rectangle2D getVisualBounds(char[] chars, int start, int limit) {
float l = Float.MAX_VALUE;
float t = l;
float r = 0;
float b = r;
float x = 0;
float[] data = null;
int n = 0;
for (int i = start; i < limit; ++i) {
char c = chars[i];
if (c < 0x100) {
n = c;
data = latin1GlyphInfo;
} else if (c >= KANA_MIN && c < KANA_LIM) {
n = c - KANA_MIN;
data = kanaGlyphInfo;
} else if (c >= CJK_MIN && c < CJK_LIM) {
if (font.canDisplay(c)) {
n = KANA_LIM - KANA_MIN;
data = kanaGlyphInfo;
} else {
n = 0;
data = missingGlyphInfo;
}
} else if (c >= CJKHALF_MIN && c < CJKHALF_LIM) {
if (font.canDisplay(c)) {
n = KANA_LIM - KANA_MIN + 1;
data = kanaGlyphInfo;
} else {
n = 0;
data = missingGlyphInfo;
}
} else if (c >= CJKFULL1_MIN && c < CJKFULL1_LIM) {
if (font.canDisplay(c)) {
n = KANA_LIM - KANA_MIN + 2;
data = kanaGlyphInfo;
} else {
n = 0;
data = missingGlyphInfo;
}
} else if (c >= CJKFULL2_MIN && c < CJKFULL2_LIM) {
if (font.canDisplay(c)) {
n = KANA_LIM - KANA_MIN + 2;
data = kanaGlyphInfo;
} else {
n = 0;
data = missingGlyphInfo;
}
} else {
// throw same error as if we'd just looked up in a table
throw new IndexOutOfBoundsException("no advance for char " + Integer.toHexString(c));
}
n *= 8;
float cl = x + data[n+4];
float ct = data[n+5];
float cr = x + data[n+6];
float cb = data[n+7];
if (cr > cl && cb > ct) { // empty paths aren't added
if (cl < l) l = cl;
if (ct < t) t = ct;
if (cr > r) r = cr;
if (cb > b) b = cb;
}
x += data[n+2];
}
return new Rectangle2D.Float(l, t, r-l, b-t);
}
public void getStats(int[] results) {
synchronized(cacheLock) {
results[0] = statCount;
results[1] = statTest;
results[2] = statMiss;
results[3] = statFlush;
results[4] = statFlushDelta;
}
}
}