--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.desktop/unix/classes/sun/font/NativeFont.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,396 @@
+/*
+ * Copyright (c) 2003, 2014, 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.FontFormatException;
+import java.awt.GraphicsEnvironment;
+import java.awt.font.FontRenderContext;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.io.UnsupportedEncodingException;
+import java.lang.ref.WeakReference;
+import java.util.Locale;
+
+/*
+ * Ideally there would be no native fonts used, and this class would be
+ * unneeded and removed. Presently it is still needed until such time
+ * as font configuration files (or the implementation equivalent) can have
+ * all references to fonts that are not handled via Java 2D removed.
+ * Currently there are two cases where this class is needed, both on
+ * Unix, primarily Solaris, but useful on Linux too if fonts have moved.
+ * 1. Some legacy F3 fonts are still referenced so that AWT "X/Motif"
+ * can get dingbats and symbols from them. This can be dispensed with when
+ * either AWT is based on 2D, or when the X font path is known to always
+ * contain a Type1 or TrueType font that can be used in font configuration
+ * files to replace the F3 fonts.
+ * 2. When location of font files by 2D fails, because of some system
+ * configuration problem, it is desirable to have a fall back to some
+ * functionality that lessens the immediate impact on users. Being able
+ * to perform limited operations by using bitmaps from X11 helps here.
+ */
+
+public class NativeFont extends PhysicalFont {
+
+ String encoding;
+
+ private int numGlyphs = -1;
+ boolean isBitmapDelegate;
+ PhysicalFont delegateFont;
+
+ /**
+ * Verifies native font is accessible.
+ * @throws FontFormatException if the font can't be located.
+ */
+ public NativeFont(String platName, boolean bitmapDelegate)
+ throws FontFormatException {
+ super(platName, null);
+
+ /* This is set true if this is an instance of a NativeFont
+ * created by some other font, to get native bitmaps.
+ * The delegating font will call this font only for "basic"
+ * cases - ie non-rotated, uniform scale, monochrome bitmaps.
+ * If this is false, then this instance may need to itself
+ * delegate to another font for non-basic cases. Since
+ * NativeFonts are used in that way only for symbol and dingbats
+ * we know its safe to delegate these to the JRE's default
+ * physical font (Lucida Sans Regular).
+ */
+ isBitmapDelegate = bitmapDelegate;
+
+ if (GraphicsEnvironment.isHeadless()) {
+ throw new FontFormatException("Native font in headless toolkit");
+ }
+ fontRank = Font2D.NATIVE_RANK;
+ initNames();
+ if (getNumGlyphs() == 0) {
+ throw new FontFormatException("Couldn't locate font" + platName);
+ }
+ }
+
+ private void initNames() throws FontFormatException {
+ /* Valid XLFD has exactly 14 "-" chars.
+ * First run over the string to verify have at least this many
+ * At the same time record the locations of the hyphens
+ * so we can just pick the right substring later on
+ */
+ int[] hPos = new int[14];
+ int hyphenCnt = 1;
+ int pos = 1;
+
+ String xlfd = platName.toLowerCase(Locale.ENGLISH);
+ if (xlfd.startsWith("-")) {
+ while (pos != -1 && hyphenCnt < 14) {
+ pos = xlfd.indexOf('-', pos);
+ if (pos != -1) {
+ hPos[hyphenCnt++] = pos;
+ pos++;
+ }
+ }
+ }
+
+ if (hyphenCnt == 14 && pos != -1) {
+
+ /* Capitalise words in the Family name */
+ String tmpFamily = xlfd.substring(hPos[1]+1, hPos[2]);
+ StringBuilder sBuffer = new StringBuilder(tmpFamily);
+ char ch = Character.toUpperCase(sBuffer.charAt(0));
+ sBuffer.replace(0, 1, String.valueOf(ch));
+ for (int i=1;i<sBuffer.length()-1; i++) {
+ if (sBuffer.charAt(i) == ' ') {
+ ch = Character.toUpperCase(sBuffer.charAt(i+1));
+ sBuffer.replace(i+1, i+2, String.valueOf(ch));
+ }
+ }
+ familyName = sBuffer.toString();
+
+ String tmpWeight = xlfd.substring(hPos[2]+1, hPos[3]);
+ String tmpSlant = xlfd.substring(hPos[3]+1, hPos[4]);
+
+ String styleStr = null;
+
+ if (tmpWeight.indexOf("bold") >= 0 ||
+ tmpWeight.indexOf("demi") >= 0) {
+ style |= Font.BOLD;
+ styleStr = "Bold";
+ }
+
+ if (tmpSlant.equals("i") ||
+ tmpSlant.indexOf("italic") >= 0) {
+ style |= Font.ITALIC;
+
+ if (styleStr == null) {
+ styleStr = "Italic";
+ } else {
+ styleStr = styleStr + " Italic";
+ }
+ }
+ else if (tmpSlant.equals("o") ||
+ tmpSlant.indexOf("oblique") >= 0) {
+ style |= Font.ITALIC;
+ if (styleStr == null) {
+ styleStr = "Oblique";
+ } else {
+ styleStr = styleStr + " Oblique";
+ }
+ }
+
+ if (styleStr == null) {
+ fullName = familyName;
+ } else {
+ fullName = familyName + " " + styleStr;
+ }
+
+ encoding = xlfd.substring(hPos[12]+1);
+ if (encoding.startsWith("-")) {
+ encoding = xlfd.substring(hPos[13]+1);
+ }
+ if (encoding.indexOf("fontspecific") >= 0) {
+ if (tmpFamily.indexOf("dingbats") >= 0) {
+ encoding = "dingbats";
+ } else if (tmpFamily.indexOf("symbol") >= 0) {
+ encoding = "symbol";
+ } else {
+ encoding = "iso8859-1";
+ }
+ }
+ } else {
+ throw new FontFormatException("Bad native name " + platName);
+// familyName = "Unknown";
+// fullName = "Unknown";
+// style = Font.PLAIN;
+// encoding = "iso8859-1";
+ }
+ }
+
+ /* Wildcard all the size fields in the XLFD and retrieve a list of
+ * XLFD's that match.
+ * We only look for scaleable fonts, so we can just replace the 0's
+ * with *'s and see what we get back
+ * No matches means even the scaleable version wasn't found. This is
+ * means the X font path isn't set up for this font at all.
+ * One match means only the scaleable version we started with was found
+ * -monotype-arial-bold-i-normal--0-0-0-0-p-0-iso8859-1
+ * Two matches apparently means as well as the above, a scaleable
+ * specified for 72 dpi is found, not that there are bitmaps : eg
+ * -monotype-arial-bold-i-normal--0-0-72-72-p-0-iso8859-1
+ * So require at least 3 matches (no need to parse) to determine that
+ * there are external bitmaps.
+ */
+ static boolean hasExternalBitmaps(String platName) {
+ /* Turn -monotype-arial-bold-i-normal--0-0-0-0-p-0-iso8859-1
+ * into -monotype-arial-bold-i-normal--*-*-*-*-p-*-iso8859-1
+ * by replacing all -0- substrings with -*-
+ */
+ StringBuilder sb = new StringBuilder(platName);
+ int pos = sb.indexOf("-0-");
+ while (pos >=0) {
+ sb.replace(pos+1, pos+2, "*");
+ pos = sb.indexOf("-0-", pos);
+ };
+ String xlfd = sb.toString();
+ byte[] bytes = null;
+ try {
+ bytes = xlfd.getBytes("UTF-8");
+ } catch (UnsupportedEncodingException e) {
+ bytes = xlfd.getBytes();
+ }
+ return haveBitmapFonts(bytes);
+ }
+
+ public static boolean fontExists(String xlfd) {
+ byte[] bytes = null;
+ try {
+ bytes = xlfd.getBytes("UTF-8");
+ } catch (UnsupportedEncodingException e) {
+ bytes = xlfd.getBytes();
+ }
+ return fontExists(bytes);
+ }
+
+ private static native boolean haveBitmapFonts(byte[] xlfd);
+ private static native boolean fontExists(byte[] xlfd);
+
+ public CharToGlyphMapper getMapper() {
+ if (mapper == null) {
+ if (isBitmapDelegate) {
+ /* we are a delegate */
+ mapper = new NativeGlyphMapper(this);
+ } else {
+ /* we need to delegate */
+ SunFontManager fm = SunFontManager.getInstance();
+ delegateFont = fm.getDefaultPhysicalFont();
+ mapper = delegateFont.getMapper();
+ }
+ }
+ return mapper;
+ }
+
+ FontStrike createStrike(FontStrikeDesc desc) {
+ if (isBitmapDelegate) {
+ return new NativeStrike(this, desc);
+ } else {
+ if (delegateFont == null) {
+ SunFontManager fm = SunFontManager.getInstance();
+ delegateFont = fm.getDefaultPhysicalFont();
+ }
+ /* If no FileFont's are found, delegate font may be
+ * a NativeFont, so we need to avoid recursing here.
+ */
+ if (delegateFont instanceof NativeFont) {
+ return new NativeStrike((NativeFont)delegateFont, desc);
+ }
+ FontStrike delegate = delegateFont.createStrike(desc);
+ return new DelegateStrike(this, desc, delegate);
+ }
+ }
+
+ public Rectangle2D getMaxCharBounds(FontRenderContext frc) {
+ return null;
+ }
+
+ native StrikeMetrics getFontMetrics(long pScalerContext);
+
+ native float getGlyphAdvance(long pContext, int glyphCode);
+
+ Rectangle2D.Float getGlyphOutlineBounds(long pScalerContext,
+ int glyphCode) {
+ return new Rectangle2D.Float(0f, 0f, 0f, 0f);
+ }
+
+ public GeneralPath getGlyphOutline(long pScalerContext,
+ int glyphCode,
+ float x,
+ float y) {
+ return null;
+ }
+
+ native long getGlyphImage(long pScalerContext, int glyphCode);
+
+ native long getGlyphImageNoDefault(long pScalerContext, int glyphCode);
+
+ void getGlyphMetrics(long pScalerContext, int glyphCode,
+ Point2D.Float metrics) {
+ throw new RuntimeException("this should be called on the strike");
+ }
+
+ public GeneralPath getGlyphVectorOutline(long pScalerContext,
+ int[] glyphs, int numGlyphs,
+ float x, float y) {
+ return null;
+ }
+
+ private native int countGlyphs(byte[] platformNameBytes, int ptSize);
+
+ public int getNumGlyphs() {
+ if (numGlyphs == -1) {
+ byte[] bytes = getPlatformNameBytes(8);
+ numGlyphs = countGlyphs(bytes, 8);
+ }
+ return numGlyphs;
+ }
+
+ PhysicalFont getDelegateFont() {
+ if (delegateFont == null) {
+ SunFontManager fm = SunFontManager.getInstance();
+ delegateFont = fm.getDefaultPhysicalFont();
+ }
+ return delegateFont;
+ }
+
+ /* Specify that the dpi is 72x72, as this corresponds to JDK's
+ * default user space. These are the 10th and 11th fields in the XLFD.
+ * ptSize in XLFD is in 10th's of a point so multiply by 10,
+ * Replace the 9th field in the XLFD (ie after the 8th hyphen)
+ * with this pt size (this corresponds to the field that's "%d" in the
+ * font configuration files). Wild card the other numeric fields.
+ * ie to request 12 pt Times New Roman italic font, use an XLFD like :
+ * -monotype-times new roman-regular-i---*-120-72-72-p-*-iso8859-1
+ */
+ @SuppressWarnings("cast")
+ byte[] getPlatformNameBytes(int ptSize) {
+ int[] hPos = new int[14];
+ int hyphenCnt = 1;
+ int pos = 1;
+
+ while (pos != -1 && hyphenCnt < 14) {
+ pos = platName.indexOf('-', pos);
+ if (pos != -1) {
+ hPos[hyphenCnt++] = pos;
+ pos++;
+ }
+ }
+ String sizeStr = Integer.toString((int)Math.abs(ptSize)*10);
+ StringBuilder sb = new StringBuilder(platName);
+ /* work backwards so as to not invalidate the positions. */
+ sb.replace(hPos[11]+1, hPos[12], "*");
+
+ sb.replace(hPos[9]+1, hPos[10], "72");
+
+ sb.replace(hPos[8]+1, hPos[9], "72");
+
+ /* replace the 3 lines above with the next 3 lines to get the 1.4.2
+ * behaviour
+ */
+// sb.replace(hPos[11]+1, hPos[12], "0");
+// sb.replace(hPos[9]+1, hPos[10], "0");
+// sb.replace(hPos[8]+1, hPos[9], "0");
+
+ sb.replace(hPos[7]+1, hPos[8], sizeStr);
+
+ sb.replace(hPos[6]+1, hPos[7], "*");
+
+ /* replace the 1 line above with the next line to get the 1.4.2
+ * behaviour
+ */
+// sb.replace(hPos[6]+1, hPos[7], "0");
+
+ /* comment out this block to the 1.4.2 behaviour */
+ if (hPos[0] == 0 && hPos[1] == 1) {
+ /* null foundry name : some linux font configuration files have
+ * symbol font entries like this and its just plain wrong.
+ * Replace with a wild card. (Although those fonts should be
+ * located via disk access rather than X11).
+ */
+ sb.replace(hPos[0]+1, hPos[1], "*");
+ }
+
+ String xlfd = sb.toString();
+ byte[] bytes = null;
+ try {
+ bytes = xlfd.getBytes("UTF-8");
+ } catch (UnsupportedEncodingException e) {
+ bytes = xlfd.getBytes();
+ }
+ return bytes;
+ }
+
+ public String toString() {
+ return " ** Native Font: Family="+familyName+ " Name="+fullName+
+ " style="+style+" nativeName="+platName;
+ }
+}