/* * Copyright (c) 2003, 2005, 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.awt.Font;import java.awt.Rectangle;import java.awt.geom.GeneralPath;import java.awt.geom.Point2D;import java.awt.geom.Rectangle2D;/* * performance: * it seems expensive that when using a composite font for * every char you have to find which "slot" can display it. * Just the fact that you need to check at all .. * A composite glyph code ducks this by encoding the slot into the * glyph code, but you still need to get from char to glyph code. */public final class CompositeStrike extends FontStrike { static final int SLOTMASK = 0xffffff; private CompositeFont compFont; private PhysicalStrike[] strikes; int numGlyphs = 0; CompositeStrike(CompositeFont font2D, FontStrikeDesc desc) { this.compFont = font2D; this.desc = desc; this.disposer = new FontStrikeDisposer(compFont, desc); if (desc.style != compFont.style) { algoStyle = true; if ((desc.style & Font.BOLD) == Font.BOLD && ((compFont.style & Font.BOLD) == 0)) { boldness = 1.33f; } if ((desc.style & Font.ITALIC) == Font.ITALIC && (compFont.style & Font.ITALIC) == 0) { italic = 0.7f; } } strikes = new PhysicalStrike[compFont.numSlots]; } /* do I need this (see Strike::compositeStrikeForGlyph) */ PhysicalStrike getStrikeForGlyph(int glyphCode) { return getStrikeForSlot(glyphCode >>> 24); } PhysicalStrike getStrikeForSlot(int slot) { PhysicalStrike strike = strikes[slot]; if (strike == null) { strike = (PhysicalStrike)(compFont.getSlotFont(slot).getStrike(desc)); strikes[slot] = strike; } return strike; } public int getNumGlyphs() { return compFont.getNumGlyphs(); } StrikeMetrics getFontMetrics() { if (strikeMetrics == null) { StrikeMetrics compMetrics = new StrikeMetrics(); for (int s=0; s<compFont.numMetricsSlots; s++) { compMetrics.merge(getStrikeForSlot(s).getFontMetrics()); } strikeMetrics = compMetrics; } return strikeMetrics; } /* Performance tweak: Slot 0 can often return all the glyphs * Note slot zero doesn't need to be masked. * Could go a step further and support getting a run of glyphs. * This would help many locales a little. * * Note that if a client constructs an invalid a composite glyph that * references an invalid slot, that the behaviour is currently * that this slot index falls through to CompositeFont.getSlotFont(int) * which will substitute a default font, from which to obtain the * strike. If its an invalid glyph code for a valid slot, then the * physical font for that slot will substitute the missing glyph. */ void getGlyphImagePtrs(int[] glyphCodes, long[] images, int len) { PhysicalStrike strike = getStrikeForSlot(0); int numptrs = strike.getSlot0GlyphImagePtrs(glyphCodes, images, len); if (numptrs == len) { return; } for (int i=numptrs; i< len; i++) { strike = getStrikeForGlyph(glyphCodes[i]); images[i] = strike.getGlyphImagePtr(glyphCodes[i] & SLOTMASK); } } long getGlyphImagePtr(int glyphCode) { PhysicalStrike strike = getStrikeForGlyph(glyphCode); return strike.getGlyphImagePtr(glyphCode & SLOTMASK); } void getGlyphImageBounds(int glyphCode, Point2D.Float pt, Rectangle result) { PhysicalStrike strike = getStrikeForGlyph(glyphCode); strike.getGlyphImageBounds(glyphCode & SLOTMASK, pt, result); } Point2D.Float getGlyphMetrics(int glyphCode) { PhysicalStrike strike = getStrikeForGlyph(glyphCode); return strike.getGlyphMetrics(glyphCode & SLOTMASK); } Point2D.Float getCharMetrics(char ch) { return getGlyphMetrics(compFont.getMapper().charToGlyph(ch)); } float getGlyphAdvance(int glyphCode) { PhysicalStrike strike = getStrikeForGlyph(glyphCode); return strike.getGlyphAdvance(glyphCode & SLOTMASK); } /* REMIND where to cache? * The glyph advance is already cached by physical strikes and that's a lot * of the work. * Also FontDesignMetrics maintains a latin char advance cache, so don't * cache advances here as apps tend to hold onto metrics objects when * performance is sensitive to it. Revisit this assumption later. */ float getCodePointAdvance(int cp) { return getGlyphAdvance(compFont.getMapper().charToGlyph(cp)); } Rectangle2D.Float getGlyphOutlineBounds(int glyphCode) { PhysicalStrike strike = getStrikeForGlyph(glyphCode); return strike.getGlyphOutlineBounds(glyphCode & SLOTMASK); } GeneralPath getGlyphOutline(int glyphCode, float x, float y) { PhysicalStrike strike = getStrikeForGlyph(glyphCode); GeneralPath path = strike.getGlyphOutline(glyphCode & SLOTMASK, x, y); if (path == null) { return new GeneralPath(); } else { return path; } } /* The physical font slot for each glyph is encoded in the glyph ID * To be as efficient as possible we find a run of glyphs from the * same slot and create a temporary array of these glyphs decoded * to the slot. The slot font is then queried for the GeneralPath * for that run of glyphs. GeneralPaths from each run are appended * to create the shape for the whole glyph array. */ GeneralPath getGlyphVectorOutline(int[] glyphs, float x, float y) { GeneralPath path = null; GeneralPath gp; int glyphIndex = 0; int[] tmpGlyphs; while (glyphIndex < glyphs.length) { int start = glyphIndex; int slot = glyphs[glyphIndex] >>> 24; while (glyphIndex < glyphs.length && (glyphs[glyphIndex+1] >>> 24) == slot) { glyphIndex++; } int tmpLen = glyphIndex-start+1; tmpGlyphs = new int[tmpLen]; for (int i=0;i<tmpLen;i++) { tmpGlyphs[i] = glyphs[i] & SLOTMASK; } gp = getStrikeForSlot(slot).getGlyphVectorOutline(tmpGlyphs, x, y); if (path == null) { path = gp; } else if (gp != null) { path.append(gp, false); } } if (path == null) { return new GeneralPath(); } else { return path; } }}
/*
* Copyright (c) 2003, 2005, 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.awt.Font;
import java.awt.Rectangle;
import java.awt.geom.GeneralPath;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
/*
* performance:
* it seems expensive that when using a composite font for
* every char you have to find which "slot" can display it.
* Just the fact that you need to check at all ..
* A composite glyph code ducks this by encoding the slot into the
* glyph code, but you still need to get from char to glyph code.
*/
public final class CompositeStrike extends FontStrike {
static final int SLOTMASK = 0xffffff;
private CompositeFont compFont;
private PhysicalStrike[] strikes;
int numGlyphs = 0;
CompositeStrike(CompositeFont font2D, FontStrikeDesc desc) {
this.compFont = font2D;
this.desc = desc;
this.disposer = new FontStrikeDisposer(compFont, desc);
if (desc.style != compFont.style) {
algoStyle = true;
if ((desc.style & Font.BOLD) == Font.BOLD &&
((compFont.style & Font.BOLD) == 0)) {
boldness = 1.33f;
}
if ((desc.style & Font.ITALIC) == Font.ITALIC &&
(compFont.style & Font.ITALIC) == 0) {
italic = 0.7f;
}
}
strikes = new PhysicalStrike[compFont.numSlots];
}
/* do I need this (see Strike::compositeStrikeForGlyph) */
PhysicalStrike getStrikeForGlyph(int glyphCode) {
return getStrikeForSlot(glyphCode >>> 24);
}
PhysicalStrike getStrikeForSlot(int slot) {
PhysicalStrike strike = strikes[slot];
if (strike == null) {
strike =
(PhysicalStrike)(compFont.getSlotFont(slot).getStrike(desc));
strikes[slot] = strike;
}
return strike;
}
public int getNumGlyphs() {
return compFont.getNumGlyphs();
}
StrikeMetrics getFontMetrics() {
if (strikeMetrics == null) {
StrikeMetrics compMetrics = new StrikeMetrics();
for (int s=0; s<compFont.numMetricsSlots; s++) {
compMetrics.merge(getStrikeForSlot(s).getFontMetrics());
}
strikeMetrics = compMetrics;
}
return strikeMetrics;
}
/* Performance tweak: Slot 0 can often return all the glyphs
* Note slot zero doesn't need to be masked.
* Could go a step further and support getting a run of glyphs.
* This would help many locales a little.
*
* Note that if a client constructs an invalid a composite glyph that
* references an invalid slot, that the behaviour is currently
* that this slot index falls through to CompositeFont.getSlotFont(int)
* which will substitute a default font, from which to obtain the
* strike. If its an invalid glyph code for a valid slot, then the
* physical font for that slot will substitute the missing glyph.
*/
void getGlyphImagePtrs(int[] glyphCodes, long[] images, int len) {
PhysicalStrike strike = getStrikeForSlot(0);
int numptrs = strike.getSlot0GlyphImagePtrs(glyphCodes, images, len);
if (numptrs == len) {
return;
}
for (int i=numptrs; i< len; i++) {
strike = getStrikeForGlyph(glyphCodes[i]);
images[i] = strike.getGlyphImagePtr(glyphCodes[i] & SLOTMASK);
}
}
long getGlyphImagePtr(int glyphCode) {
PhysicalStrike strike = getStrikeForGlyph(glyphCode);
return strike.getGlyphImagePtr(glyphCode & SLOTMASK);
}
void getGlyphImageBounds(int glyphCode, Point2D.Float pt, Rectangle result) {
PhysicalStrike strike = getStrikeForGlyph(glyphCode);
strike.getGlyphImageBounds(glyphCode & SLOTMASK, pt, result);
}
Point2D.Float getGlyphMetrics(int glyphCode) {
PhysicalStrike strike = getStrikeForGlyph(glyphCode);
return strike.getGlyphMetrics(glyphCode & SLOTMASK);
}
Point2D.Float getCharMetrics(char ch) {
return getGlyphMetrics(compFont.getMapper().charToGlyph(ch));
}
float getGlyphAdvance(int glyphCode) {
PhysicalStrike strike = getStrikeForGlyph(glyphCode);
return strike.getGlyphAdvance(glyphCode & SLOTMASK);
}
/* REMIND where to cache?
* The glyph advance is already cached by physical strikes and that's a lot
* of the work.
* Also FontDesignMetrics maintains a latin char advance cache, so don't
* cache advances here as apps tend to hold onto metrics objects when
* performance is sensitive to it. Revisit this assumption later.
*/
float getCodePointAdvance(int cp) {
return getGlyphAdvance(compFont.getMapper().charToGlyph(cp));
}
Rectangle2D.Float getGlyphOutlineBounds(int glyphCode) {
PhysicalStrike strike = getStrikeForGlyph(glyphCode);
return strike.getGlyphOutlineBounds(glyphCode & SLOTMASK);
}
GeneralPath getGlyphOutline(int glyphCode, float x, float y) {
PhysicalStrike strike = getStrikeForGlyph(glyphCode);
GeneralPath path = strike.getGlyphOutline(glyphCode & SLOTMASK, x, y);
if (path == null) {
return new GeneralPath();
} else {
return path;
}
}
/* The physical font slot for each glyph is encoded in the glyph ID
* To be as efficient as possible we find a run of glyphs from the
* same slot and create a temporary array of these glyphs decoded
* to the slot. The slot font is then queried for the GeneralPath
* for that run of glyphs. GeneralPaths from each run are appended
* to create the shape for the whole glyph array.
*/
GeneralPath getGlyphVectorOutline(int[] glyphs, float x, float y) {
GeneralPath path = null;
GeneralPath gp;
int glyphIndex = 0;
int[] tmpGlyphs;
while (glyphIndex < glyphs.length) {
int start = glyphIndex;
int slot = glyphs[glyphIndex] >>> 24;
while (glyphIndex < glyphs.length &&
(glyphs[glyphIndex+1] >>> 24) == slot) {
glyphIndex++;
}
int tmpLen = glyphIndex-start+1;
tmpGlyphs = new int[tmpLen];
for (int i=0;i<tmpLen;i++) {
tmpGlyphs[i] = glyphs[i] & SLOTMASK;
}
gp = getStrikeForSlot(slot).getGlyphVectorOutline(tmpGlyphs, x, y);
if (path == null) {
path = gp;
} else if (gp != null) {
path.append(gp, false);
}
}
if (path == null) {
return new GeneralPath();
} else {
return path;
}
}
}