devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

IDEA编译JDK1.8源码及运行测试_idea配置jdk1.8

作者：从前慢现在也慢 | 2024-04-17 20:50:44

赞

踩

idea配置jdk1.8

————————————————
版权声明：本文为CSDN博主「神韵499」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41055045/article/details/112002440
————————————————

目录

一、JDK源码源码导入IDEA前资源准备

1.在自己安装好的JDK1.8版本目录下，找到src.zip，这个就是源码（没有JDK1.8的自行去官网下载，我的版本是jdk1.8.0_271）

2.在自己电脑磁盘新建项目目录JDK1.8.0_271_source，将src解压到项目目录下，然后删掉src.zip

二、导入IDEA并配置

1.File-Open，找到自己项目导入

2.导进入后，你打开一个java文件会发现这个不可识别。此时需要将src标记为资源目录即可

3.设置编译内存，由原来的700改成1000或者更高，防止后面编译内存不足而失败

4.新建sun包，awt包和UNIXToolkit类，font包和FontConfigManager。类的具体内容文章最后面会给出

5.打开项目配置，将Jdk的lib目录下的tools.jar导入项目，编译所需要它

6.配置一个新的JDK，然后改名称，并配置源码为自己的代码 待会debug可以切换进来

三、编写测试类

1.在src目录下编写一个测试类MainTest.java并运行，便会自动编译（确保上面每一步做到位，编译才不会出错）

2.编译成功后，在自己源码HashMap构造函数加断点并加注释

3.debug运行MainTest.java进入源码

四、JDK缺少的类内容

1.sun.awt.UNIXToolkit

2.sun.font.FontConfigManager

一、JDK源码源码导入IDEA前资源准备
1.在自己安装好的JDK1.8版本目录下，找到src.zip，这个就是源码（没有JDK1.8的自行去官网下载，我的版本是jdk1.8.0_271）

2.在自己电脑磁盘新建项目目录JDK1.8.0_271_source，将src解压到项目目录下，然后删掉src.zip

二、导入IDEA并配置
1.File-Open，找到自己项目导入

最终项目目录效果
 

2.导进入后，你打开一个java文件会发现这个不可识别。此时需要将src标记为资源目录即可

 

3.设置编译内存，由原来的700改成1000或者更高，防止后面编译内存不足而失败

4.新建sun包，awt包和UNIXToolkit类，font包和FontConfigManager。类的具体内容文章最后面会给出

添加缺少内容

5.打开项目配置，将Jdk的lib目录下的tools.jar导入项目，编译所需要它

引入tools.jar

tools.jar

最终效果
 

6.配置一个新的JDK，然后改名称，并配置源码为自己的代码 待会debug可以切换进来

配置一个新的JDK

 

 

改名称

这一步是关键，设置了后，待会debug就可以切换成自己源码目录了


替换源码目录
Apply 保存以上所有配置，IDEA配置结束!

三、编写测试类
1.在src目录下编写一个测试类MainTest.java并运行，便会自动编译（确保上面每一步做到位，编译才不会出错）


提示设置输出class目录

 

点击OK，跳出目录，先在源码路径下建立文件夹out，然后设置在项目路径下out目录下即可

运行编译中

 

编译成功，用了差不多2分钟

2.编译成功后，在自己源码HashMap构造函数加断点并加注释
双击shift搜索HashMap，确保是进入本项目源码构造函数，而不是jdk自带的源码那


本项目下搜索​​​​
加断点和注释

 


给自己项目源码加断点加注释
 
3.debug运行MainTest.java进入源码


进自己源码还需要自行去切换，有些如果没有disable这个弹出，需要自己搜索去配置（https://blog.csdn.net/qq_28455613/article/details/81382484）

 

切换，进来了

最终完成编译与测试。

事后补充（重重重！！！）

这里有三个注意点

第一个是尽量不要将debug断点打在构造函数上，上面打在构造函数上是我的过失（上面会初始化很多HashMap容器，你应该打在已经初始化完成后的地方）

第二个是如果debug不能一步一步点进去，则需要将IDEA默认不支持JDK调试的开关打开，如下图

第三个是尽量不要新起注释行，否则导致和源码行号对不上，debug错位（其实我也不喜欢行尾注释，难...，还有解决方法，参考：写Java这么久，JDK源码编译过没？编译JDK源码踩坑纪实）

 

 四、JDK缺少的类内容

1.sun.awt.UNIXToolkit

  1. package sun.awt;
  2.  
  3. /**
  4.  * @author ：HUANG ZHI XUE
  5.  * @date ：Create in 2020-12-31
  6.  */
  7.  
  8. import com.sun.java.swing.plaf.gtk.GTKConstants.TextDirection;
  9. import sun.java2d.opengl.OGLRenderQueue;
  10. import sun.security.action.GetIntegerAction;
  11. import sun.security.action.GetPropertyAction;
  12.  
  13. import java.awt.*;
  14. import java.awt.color.ColorSpace;
  15. import java.awt.image.*;
  16. import java.security.AccessController;
  17. import java.security.PrivilegedAction;
  18.  
  19. import static java.awt.RenderingHints.*;
  20.  
  21. public abstract class UNIXToolkit extends SunToolkit
  22. {
  23.     /** All calls into GTK should be synchronized on this lock */
  24.     public static final Object GTK_LOCK = new Object();
  25.  
  26.     private static final int[] BAND_OFFSETS = { 0, 1, 2 };
  27.     private static final int[] BAND_OFFSETS_ALPHA = { 0, 1, 2, 3 };
  28.     private static final int DEFAULT_DATATRANSFER_TIMEOUT = 10000;
  29.  
  30.     // Allowed GTK versions
  31.     public enum GtkVersions {
  32.         ANY(0),
  33.         GTK2(Constants.GTK2_MAJOR_NUMBER),
  34.         GTK3(Constants.GTK3_MAJOR_NUMBER);
  35.  
  36.         static class Constants {
  37.             static final int GTK2_MAJOR_NUMBER = 2;
  38.             static final int GTK3_MAJOR_NUMBER = 3;
  39.         }
  40.  
  41.         final int number;
  42.  
  43.         GtkVersions(int number) {
  44.             this.number = number;
  45.         }
  46.  
  47.         public static GtkVersions getVersion(int number) {
  48.             switch (number) {
  49.                 case Constants.GTK2_MAJOR_NUMBER:
  50.                     return GTK2;
  51.                 case Constants.GTK3_MAJOR_NUMBER:
  52.                     return GTK3;
  53.                 default:
  54.                     return ANY;
  55.             }
  56.         }
  57.  
  58.         // major GTK version number
  59.         public int getNumber() {
  60.             return number;
  61.         }
  62.     };
  63.  
  64.     private Boolean nativeGTKAvailable;
  65.     private Boolean nativeGTKLoaded;
  66.     private BufferedImage tmpImage = null;
  67.  
  68.     public static int getDatatransferTimeout() {
  69.         Integer dt = (Integer)AccessController.doPrivileged(
  70.                 new GetIntegerAction("sun.awt.datatransfer.timeout"));
  71.         if (dt == null || dt <= 0) {
  72.             return DEFAULT_DATATRANSFER_TIMEOUT;
  73.         } else {
  74.             return dt;
  75.         }
  76.     }
  77.  
  78.     /**
  79.      * Returns true if the native GTK libraries are capable of being
  80.      * loaded and are expected to work properly, false otherwise.  Note
  81.      * that this method will not leave the native GTK libraries loaded if
  82.      * they haven't already been loaded.  This allows, for example, Swing's
  83.      * GTK L&F to test for the presence of native GTK support without
  84.      * leaving the native libraries loaded.  To attempt long-term loading
  85.      * of the native GTK libraries, use the loadGTK() method instead.
  86.      */
  87.     @Override
  88.     public boolean isNativeGTKAvailable() {
  89.         synchronized (GTK_LOCK) {
  90.             if (nativeGTKLoaded != null) {
  91.                 // We've already attempted to load GTK, so just return the
  92.                 // status of that attempt.
  93.                 return nativeGTKLoaded;
  94.  
  95.             } else if (nativeGTKAvailable != null) {
  96.                 // We've already checked the availability of the native GTK
  97.                 // libraries, so just return the status of that attempt.
  98.                 return nativeGTKAvailable;
  99.  
  100.             } else {
  101.                 boolean success = check_gtk(getEnabledGtkVersion().getNumber());
  102.                 nativeGTKAvailable = success;
  103.                 return success;
  104.             }
  105.         }
  106.     }
  107.  
  108.     /**
  109.      * Loads the GTK libraries, if necessary.  The first time this method
  110.      * is called, it will attempt to load the native GTK library.  If
  111.      * successful, it leaves the library open and returns true; otherwise,
  112.      * the library is left closed and returns false.  On future calls to
  113.      * this method, the status of the first attempt is returned (a simple
  114.      * lightweight boolean check, no native calls required).
  115.      */
  116.     public boolean loadGTK() {
  117.         synchronized (GTK_LOCK) {
  118.             if (nativeGTKLoaded == null) {
  119.                 nativeGTKLoaded = load_gtk(getEnabledGtkVersion().getNumber(),
  120.                         isGtkVerbose());
  121.             }
  122.         }
  123.         return nativeGTKLoaded;
  124.     }
  125.  
  126.     /**
  127.      * Overridden to handle GTK icon loading
  128.      */
  129.     protected Object lazilyLoadDesktopProperty(String name) {
  130.         if (name.startsWith("gtk.icon.")) {
  131.             return lazilyLoadGTKIcon(name);
  132.         }
  133.         return super.lazilyLoadDesktopProperty(name);
  134.     }
  135.  
  136.     /**
  137.      * Load a native Gtk stock icon.
  138.      *
  139.      * @param longname a desktop property name. This contains icon name, size
  140.      *        and orientation, e.g. <code>"gtk.icon.gtk-add.4.rtl"</code>
  141.      * @return an <code>Image</code> for the icon, or <code>null</code> if the
  142.      *         icon could not be loaded
  143.      */
  144.     protected Object lazilyLoadGTKIcon(String longname) {
  145.         // Check if we have already loaded it.
  146.         Object result = desktopProperties.get(longname);
  147.         if (result != null) {
  148.             return result;
  149.         }
  150.  
  151.         // We need to have at least gtk.icon.<stock_id>.<size>.<orientation>
  152.         String str[] = longname.split("\\.");
  153.         if (str.length != 5) {
  154.             return null;
  155.         }
  156.  
  157.         // Parse out the stock icon size we are looking for.
  158.         int size = 0;
  159.         try {
  160.             size = Integer.parseInt(str[3]);
  161.         } catch (NumberFormatException nfe) {
  162.             return null;
  163.         }
  164.  
  165.         // Direction.
  166.         TextDirection dir = ("ltr".equals(str[4]) ? TextDirection.LTR :
  167.                 TextDirection.RTL);
  168.  
  169.         // Load the stock icon.
  170.         BufferedImage img = getStockIcon(-1, str[2], size, dir.ordinal(), null);
  171.         if (img != null) {
  172.             // Create the desktop property for the icon.
  173.             setDesktopProperty(longname, img);
  174.         }
  175.         return img;
  176.     }
  177.  
  178.     /**
  179.      * Returns a BufferedImage which contains the Gtk icon requested.  If no
  180.      * such icon exists or an error occurs loading the icon the result will
  181.      * be null.
  182.      *
  183.      * @param filename
  184.      * @return The icon or null if it was not found or loaded.
  185.      */
  186.     public BufferedImage getGTKIcon(final String filename) {
  187.         if (!loadGTK()) {
  188.             return null;
  189.  
  190.         } else {
  191.             // Call the native method to load the icon.
  192.             synchronized (GTK_LOCK) {
  193.                 if (!load_gtk_icon(filename)) {
  194.                     tmpImage = null;
  195.                 }
  196.             }
  197.         }
  198.         // Return local image the callback loaded the icon into.
  199.         return tmpImage;
  200.     }
  201.  
  202.     /**
  203.      * Returns a BufferedImage which contains the Gtk stock icon requested.
  204.      * If no such stock icon exists the result will be null.
  205.      *
  206.      * @param widgetType one of WidgetType values defined in GTKNativeEngine or
  207.      * -1 for system default stock icon.
  208.      * @param stockId String which defines the stock id of the gtk item.
  209.      * For a complete list reference the API at www.gtk.org for StockItems.
  210.      * @param iconSize One of the GtkIconSize values defined in GTKConstants
  211.      * @param textDirection One of the TextDirection values defined in
  212.      * GTKConstants
  213.      * @param detail Render detail that is passed to the native engine (feel
  214.      * free to pass null)
  215.      * @return The stock icon or null if it was not found or loaded.
  216.      */
  217.     public BufferedImage getStockIcon(final int widgetType, final String stockId,
  218.                                       final int iconSize, final int direction,
  219.                                       final String detail) {
  220.         if (!loadGTK()) {
  221.             return null;
  222.  
  223.         } else {
  224.             // Call the native method to load the icon.
  225.             synchronized (GTK_LOCK) {
  226.                 if (!load_stock_icon(widgetType, stockId, iconSize, direction, detail)) {
  227.                     tmpImage = null;
  228.                 }
  229.             }
  230.         }
  231.         // Return local image the callback loaded the icon into.
  232.         return tmpImage;  // set by loadIconCallback
  233.     }
  234.  
  235.     /**
  236.      * This method is used by JNI as a callback from load_stock_icon.
  237.      * Image data is passed back to us via this method and loaded into the
  238.      * local BufferedImage and then returned via getStockIcon.
  239.      *
  240.      * Do NOT call this method directly.
  241.      */
  242.     public void loadIconCallback(byte[] data, int width, int height,
  243.                                  int rowStride, int bps, int channels, boolean alpha) {
  244.         // Reset the stock image to null.
  245.         tmpImage = null;
  246.  
  247.         // Create a new BufferedImage based on the data returned from the
  248.         // JNI call.
  249.         DataBuffer dataBuf = new DataBufferByte(data, (rowStride * height));
  250.         // Maybe test # channels to determine band offsets?
  251.         WritableRaster raster = Raster.createInterleavedRaster(dataBuf,
  252.                 width, height, rowStride, channels,
  253.                 (alpha ? BAND_OFFSETS_ALPHA : BAND_OFFSETS), null);
  254.         ColorModel colorModel = new ComponentColorModel(
  255.                 ColorSpace.getInstance(ColorSpace.CS_sRGB), alpha, false,
  256.                 ColorModel.TRANSLUCENT, DataBuffer.TYPE_BYTE);
  257.  
  258.         // Set the local image so we can return it later from
  259.         // getStockIcon().
  260.         tmpImage = new BufferedImage(colorModel, raster, false, null);
  261.     }
  262.  
  263.     private static native boolean check_gtk(int version);
  264.     private static native boolean load_gtk(int version, boolean verbose);
  265.     private static native boolean unload_gtk();
  266.     private native boolean load_gtk_icon(String filename);
  267.     private native boolean load_stock_icon(int widget_type, String stock_id,
  268.                                            int iconSize, int textDirection, String detail);
  269.  
  270.     private native void nativeSync();
  271.     private static native int get_gtk_version();
  272.  
  273.     @Override
  274.     public void sync() {
  275.         // flush the X11 buffer
  276.         nativeSync();
  277.         // now flush the OGL pipeline (this is a no-op if OGL is not enabled)
  278.         OGLRenderQueue.sync();
  279.     }
  280.  
  281.     /*
  282.      * This returns the value for the desktop property "awt.font.desktophints"
  283.      * It builds this by querying the Gnome desktop properties to return
  284.      * them as platform independent hints.
  285.      * This requires that the Gnome properties have already been gathered.
  286.      */
  287.     public static final String FONTCONFIGAAHINT = "fontconfig/Antialias";
  288.  
  289.     @Override
  290.     protected RenderingHints getDesktopAAHints() {
  291.  
  292.         Object aaValue = getDesktopProperty("gnome.Xft/Antialias");
  293.  
  294.         if (aaValue == null) {
  295.             /* On a KDE desktop running KWin the rendering hint will
  296.              * have been set as property "fontconfig/Antialias".
  297.              * No need to parse further in this case.
  298.              */
  299.             aaValue = getDesktopProperty(FONTCONFIGAAHINT);
  300.             if (aaValue != null) {
  301.                 return new RenderingHints(KEY_TEXT_ANTIALIASING, aaValue);
  302.             } else {
  303.                 return null; // no Gnome or KDE Desktop properties available.
  304.             }
  305.         }
  306.  
  307.         /* 0 means off, 1 means some ON. What would any other value mean?
  308.          * If we require "1" to enable AA then some new value would cause
  309.          * us to default to "OFF". I don't think that's the best guess.
  310.          * So if its !=0 then lets assume AA.
  311.          */
  312.         boolean aa = ((aaValue instanceof Number)
  313.                 && ((Number) aaValue).intValue() != 0);
  314.         Object aaHint;
  315.         if (aa) {
  316.             String subpixOrder =
  317.                     (String)getDesktopProperty("gnome.Xft/RGBA");
  318.  
  319.             if (subpixOrder == null || subpixOrder.equals("none")) {
  320.                 aaHint = VALUE_TEXT_ANTIALIAS_ON;
  321.             } else if (subpixOrder.equals("rgb")) {
  322.                 aaHint = VALUE_TEXT_ANTIALIAS_LCD_HRGB;
  323.             } else if (subpixOrder.equals("bgr")) {
  324.                 aaHint = VALUE_TEXT_ANTIALIAS_LCD_HBGR;
  325.             } else if (subpixOrder.equals("vrgb")) {
  326.                 aaHint = VALUE_TEXT_ANTIALIAS_LCD_VRGB;
  327.             } else if (subpixOrder.equals("vbgr")) {
  328.                 aaHint = VALUE_TEXT_ANTIALIAS_LCD_VBGR;
  329.             } else {
  330.                 /* didn't recognise the string, but AA is requested */
  331.                 aaHint = VALUE_TEXT_ANTIALIAS_ON;
  332.             }
  333.         } else {
  334.             aaHint = VALUE_TEXT_ANTIALIAS_DEFAULT;
  335.         }
  336.         return new RenderingHints(KEY_TEXT_ANTIALIASING, aaHint);
  337.     }
  338.  
  339.     private native boolean gtkCheckVersionImpl(int major, int minor,
  340.                                                int micro);
  341.  
  342.     /**
  343.      * Returns {@code true} if the GTK+ library is compatible with the given
  344.      * version.
  345.      *
  346.      * @param major
  347.      *            The required major version.
  348.      * @param minor
  349.      *            The required minor version.
  350.      * @param micro
  351.      *            The required micro version.
  352.      * @return {@code true} if the GTK+ library is compatible with the given
  353.      *         version.
  354.      */
  355.     public boolean checkGtkVersion(int major, int minor, int micro) {
  356.         if (loadGTK()) {
  357.             return gtkCheckVersionImpl(major, minor, micro);
  358.         }
  359.         return false;
  360.     }
  361.  
  362.     public static GtkVersions getEnabledGtkVersion() {
  363.         String version = AccessController.doPrivileged(
  364.                 new GetPropertyAction("jdk.gtk.version"));
  365.         if (version == null) {
  366.             return GtkVersions.ANY;
  367.         } else if (version.startsWith("2")) {
  368.             return GtkVersions.GTK2;
  369.         } else if("3".equals(version) ){
  370.             return GtkVersions.GTK3;
  371.         }
  372.         return GtkVersions.ANY;
  373.     }
  374.  
  375.     public static GtkVersions getGtkVersion() {
  376.         return GtkVersions.getVersion(get_gtk_version());
  377.     }
  378.  
  379.     public static boolean isGtkVerbose() {
  380.         return AccessController.doPrivileged((PrivilegedAction<Boolean>)()
  381.                 -> Boolean.getBoolean("jdk.gtk.verbose"));
  382.     }
  383. }

2.sun.font.FontConfigManager

  1. package sun.font;
  2.  
  3. /**
  4.  * @author ：HUANG ZHI XUE
  5.  * @date ：Create in 2020-12-31
  6.  */
  7.  
  8. import sun.awt.SunHints;
  9. import sun.awt.SunToolkit;
  10. import sun.util.logging.PlatformLogger;
  11.  
  12. import java.util.Locale;
  13.  
  14. /**
  15.  * Small utility class to manage FontConfig.
  16.  */
  17. public class FontConfigManager {
  18.  
  19.     static boolean fontConfigFailed = false;
  20.  
  21.     /* This is populated by native */
  22.     private static final FontConfigInfo fcInfo = new FontConfigInfo();
  23.  
  24.     /* Begin support for GTK Look and Feel - query libfontconfig and
  25.      * return a composite Font to Swing that uses the desktop font(s).
  26.      */
  27.  
  28.     /* These next three classes are just data structures.
  29.      */
  30.     public static class FontConfigFont {
  31.         public String familyName;        // eg Bitstream Vera Sans
  32.         public String styleStr;          // eg Bold
  33.         public String fullName;          // eg Bitstream Vera Sans Bold
  34.         public String fontFile;          // eg /usr/X11/lib/fonts/foo.ttf
  35.     }
  36.  
  37.     public static class FcCompFont {
  38.         public String fcName;            // eg sans
  39.         public String fcFamily;          // eg sans
  40.         public String jdkName;           // eg sansserif
  41.         public int style;                // eg 0=PLAIN
  42.         public FontConfigFont firstFont;
  43.         public FontConfigFont[] allFonts;
  44.         //boolean preferBitmaps;    // if embedded bitmaps preferred over AA
  45.         public CompositeFont compFont;   // null if not yet created/known.
  46.     }
  47.  
  48.     public static class FontConfigInfo {
  49.         public int fcVersion;
  50.         public String[] cacheDirs = new String[4];
  51.     }
  52.  
  53.     /* fontconfig recognises slants roman, italic, as well as oblique,
  54.      * and a slew of weights, where the ones that matter here are
  55.      * regular and bold.
  56.      * To fully qualify what we want, we can for example ask for (eg)
  57.      * Font.PLAIN             : "serif:regular:roman"
  58.      * Font.BOLD              : "serif:bold:roman"
  59.      * Font.ITALIC            : "serif:regular:italic"
  60.      * Font.BOLD|Font.ITALIC  : "serif:bold:italic"
  61.      */
  62.     private static String[] fontConfigNames = {
  63.             "sans:regular:roman",
  64.             "sans:bold:roman",
  65.             "sans:regular:italic",
  66.             "sans:bold:italic",
  67.  
  68.             "serif:regular:roman",
  69.             "serif:bold:roman",
  70.             "serif:regular:italic",
  71.             "serif:bold:italic",
  72.  
  73.             "monospace:regular:roman",
  74.             "monospace:bold:roman",
  75.             "monospace:regular:italic",
  76.             "monospace:bold:italic",
  77.     };
  78.  
  79.     /* This array has the array elements created in Java code and is
  80.      * passed down to native to be filled in.
  81.      */
  82.     private FcCompFont[] fontConfigFonts;
  83.  
  84.     /**
  85.      * Instantiates a new FontConfigManager getting the default instance
  86.      * of FontManager from the FontManagerFactory.
  87.      */
  88.     public FontConfigManager() {
  89.     }
  90.  
  91.     /* Called from code that needs to know what are the AA settings
  92.      * that apps using FC would pick up for the default desktop font.
  93.      * Note apps can change the default desktop font. etc, so this
  94.      * isn't certain to be right but its going to correct for most cases.
  95.      * Native return values map to the text aa values in sun.awt.SunHints.
  96.      * which is used to look up the renderinghint value object.
  97.      */
  98.     public static Object getFontConfigAAHint() {
  99.         return getFontConfigAAHint("sans");
  100.     }
  101.  
  102.     /* This is public solely so that for debugging purposes it can be called
  103.      * with other names, which might (eg) include a size, eg "sans-24"
  104.      * The return value is a text aa rendering hint value.
  105.      * Normally we should call the no-args version.
  106.      */
  107.     public static Object getFontConfigAAHint(String fcFamily) {
  108.         if (FontUtilities.isWindows) {
  109.             return null;
  110.         } else {
  111.             int hint = getFontConfigAASettings(getFCLocaleStr(), fcFamily);
  112.             if (hint < 0) {
  113.                 return null;
  114.             } else {
  115.                 return SunHints.Value.get(SunHints.INTKEY_TEXT_ANTIALIASING,
  116.                         hint);
  117.             }
  118.         }
  119.     }
  120.  
  121.  
  122.     private static String getFCLocaleStr() {
  123.         Locale l = SunToolkit.getStartupLocale();
  124.         String localeStr = l.getLanguage();
  125.         String country = l.getCountry();
  126.         if (!country.equals("")) {
  127.             localeStr = localeStr + "-" + country;
  128.         }
  129.         return localeStr;
  130.     }
  131.  
  132.     /* This does cause the native libfontconfig to be loaded and unloaded,
  133.      * but it does not incur the overhead of initialisation of its
  134.      * data structures, so shouldn't have a measurable impact.
  135.      */
  136.     public static native int getFontConfigVersion();
  137.  
  138.     /* This can be made public if it's needed to force a re-read
  139.      * rather than using the cached values. The re-read would be needed
  140.      * only if some event signalled that the fontconfig has changed.
  141.      * In that event this method would need to return directly the array
  142.      * to be used by the caller in case it subsequently changed.
  143.      */
  144.     public synchronized void initFontConfigFonts(boolean includeFallbacks) {
  145.  
  146.         if (fontConfigFonts != null) {
  147.             if (!includeFallbacks || (fontConfigFonts[0].allFonts != null)) {
  148.                 return;
  149.             }
  150.         }
  151.  
  152.         if (FontUtilities.isWindows || fontConfigFailed) {
  153.             return;
  154.         }
  155.  
  156.         long t0 = 0;
  157.         if (FontUtilities.isLogging()) {
  158.             t0 = System.nanoTime();
  159.         }
  160.  
  161.         FcCompFont[] fontArr = new FcCompFont[fontConfigNames.length];
  162.  
  163.         for (int i = 0; i< fontArr.length; i++) {
  164.             fontArr[i] = new FcCompFont();
  165.             fontArr[i].fcName = fontConfigNames[i];
  166.             int colonPos = fontArr[i].fcName.indexOf(':');
  167.             fontArr[i].fcFamily = fontArr[i].fcName.substring(0, colonPos);
  168.             fontArr[i].jdkName = FontUtilities.mapFcName(fontArr[i].fcFamily);
  169.             fontArr[i].style = i % 4; // depends on array order.
  170.         }
  171.         getFontConfig(getFCLocaleStr(), fcInfo, fontArr, includeFallbacks);
  172.         FontConfigFont anyFont = null;
  173.         /* If don't find anything (eg no libfontconfig), then just return */
  174.         for (int i = 0; i< fontArr.length; i++) {
  175.             FcCompFont fci = fontArr[i];
  176.             if (fci.firstFont == null) {
  177.                 if (FontUtilities.isLogging()) {
  178.                     PlatformLogger logger = FontUtilities.getLogger();
  179.                     logger.info("Fontconfig returned no font for " +
  180.                             fontArr[i].fcName);
  181.                 }
  182.                 fontConfigFailed = true;
  183.             } else if (anyFont == null) {
  184.                 anyFont = fci.firstFont;
  185.             }
  186.         }
  187.  
  188.         if (anyFont == null) {
  189.             if (FontUtilities.isLogging()) {
  190.                 PlatformLogger logger = FontUtilities.getLogger();
  191.                 logger.info("Fontconfig returned no fonts at all.");
  192.             }
  193.             fontConfigFailed = true;
  194.             return;
  195.         } else if (fontConfigFailed) {
  196.             for (int i = 0; i< fontArr.length; i++) {
  197.                 if (fontArr[i].firstFont == null) {
  198.                     fontArr[i].firstFont = anyFont;
  199.                 }
  200.             }
  201.         }
  202.  
  203.         fontConfigFonts = fontArr;
  204.  
  205.         if (FontUtilities.isLogging()) {
  206.  
  207.             PlatformLogger logger = FontUtilities.getLogger();
  208.  
  209.             long t1 = System.nanoTime();
  210.             logger.info("Time spent accessing fontconfig="
  211.                     + ((t1 - t0) / 1000000) + "ms.");
  212.  
  213.             for (int i = 0; i< fontConfigFonts.length; i++) {
  214.                 FcCompFont fci = fontConfigFonts[i];
  215.                 logger.info("FC font " + fci.fcName+" maps to family " +
  216.                         fci.firstFont.familyName +
  217.                         " in file " + fci.firstFont.fontFile);
  218.                 if (fci.allFonts != null) {
  219.                     for (int f=0;f<fci.allFonts.length;f++) {
  220.                         FontConfigFont fcf = fci.allFonts[f];
  221.                         logger.info("Family=" + fcf.familyName +
  222.                                 " Style="+ fcf.styleStr +
  223.                                 " Fullname="+fcf.fullName +
  224.                                 " File="+fcf.fontFile);
  225.                     }
  226.                 }
  227.             }
  228.         }
  229.     }
  230.  
  231.     public PhysicalFont registerFromFcInfo(FcCompFont fcInfo) {
  232.  
  233.         SunFontManager fm = SunFontManager.getInstance();
  234.  
  235.         /* If it's a TTC file we need to know that as we will need to
  236.          * make sure we return the right font */
  237.         String fontFile = fcInfo.firstFont.fontFile;
  238.         int offset = fontFile.length()-4;
  239.         if (offset <= 0) {
  240.             return null;
  241.         }
  242.         String ext = fontFile.substring(offset).toLowerCase();
  243.         boolean isTTC = ext.equals(".ttc");
  244.  
  245.         /* If this file is already registered, can just return its font.
  246.          * However we do need to check in case it's a TTC as we need
  247.          * a specific font, so rather than directly returning it, let
  248.          * findFont2D resolve that.
  249.          */
  250.         PhysicalFont physFont = fm.getRegisteredFontFile(fontFile);
  251.         if (physFont != null) {
  252.             if (isTTC) {
  253.                 Font2D f2d = fm.findFont2D(fcInfo.firstFont.familyName,
  254.                         fcInfo.style,
  255.                         FontManager.NO_FALLBACK);
  256.                 if (f2d instanceof PhysicalFont) { /* paranoia */
  257.                     return (PhysicalFont)f2d;
  258.                 } else {
  259.                     return null;
  260.                 }
  261.             } else {
  262.                 return physFont;
  263.             }
  264.         }
  265.  
  266.         /* If the font may hide a JRE font (eg fontconfig says it is
  267.          * Lucida Sans), we want to use the JRE version, so make it
  268.          * point to the JRE font.
  269.          */
  270.         physFont = fm.findJREDeferredFont(fcInfo.firstFont.familyName,
  271.                 fcInfo.style);
  272.  
  273.         /* It is also possible the font file is on the "deferred" list,
  274.          * in which case we can just initialise it now.
  275.          */
  276.         if (physFont == null &&
  277.                 fm.isDeferredFont(fontFile) == true) {
  278.             physFont = fm.initialiseDeferredFont(fcInfo.firstFont.fontFile);
  279.             /* use findFont2D to get the right font from TTC's */
  280.             if (physFont != null) {
  281.                 if (isTTC) {
  282.                     Font2D f2d = fm.findFont2D(fcInfo.firstFont.familyName,
  283.                             fcInfo.style,
  284.                             FontManager.NO_FALLBACK);
  285.                     if (f2d instanceof PhysicalFont) { /* paranoia */
  286.                         return (PhysicalFont)f2d;
  287.                     } else {
  288.                         return null;
  289.                     }
  290.                 } else {
  291.                     return physFont;
  292.                 }
  293.             }
  294.         }
  295.  
  296.         /* In the majority of cases we reach here, and need to determine
  297.          * the type and rank to register the font.
  298.          */
  299.         if (physFont == null) {
  300.             int fontFormat = SunFontManager.FONTFORMAT_NONE;
  301.             int fontRank = Font2D.UNKNOWN_RANK;
  302.  
  303.             if (ext.equals(".ttf") || isTTC) {
  304.                 fontFormat = SunFontManager.FONTFORMAT_TRUETYPE;
  305.                 fontRank = Font2D.TTF_RANK;
  306.             } else if (ext.equals(".pfa") || ext.equals(".pfb")) {
  307.                 fontFormat = SunFontManager.FONTFORMAT_TYPE1;
  308.                 fontRank = Font2D.TYPE1_RANK;
  309.             }
  310.             physFont = fm.registerFontFile(fcInfo.firstFont.fontFile, null,
  311.                     fontFormat, true, fontRank);
  312.         }
  313.         return physFont;
  314.     }
  315.  
  316.     /*
  317.      * We need to return a Composite font which has as the font in
  318.      * its first slot one obtained from fontconfig.
  319.      */
  320.     public CompositeFont getFontConfigFont(String name, int style) {
  321.  
  322.         name = name.toLowerCase();
  323.  
  324.         initFontConfigFonts(false);
  325.         if (fontConfigFonts == null) {
  326.             // This avoids an immediate NPE if fontconfig look up failed
  327.             // but doesn't guarantee this is a recoverable situation.
  328.             return null;
  329.         }
  330.  
  331.         FcCompFont fcInfo = null;
  332.         for (int i=0; i<fontConfigFonts.length; i++) {
  333.             if (name.equals(fontConfigFonts[i].fcFamily) &&
  334.                     style == fontConfigFonts[i].style) {
  335.                 fcInfo = fontConfigFonts[i];
  336.                 break;
  337.             }
  338.         }
  339.         if (fcInfo == null) {
  340.             fcInfo = fontConfigFonts[0];
  341.         }
  342.  
  343.         if (FontUtilities.isLogging()) {
  344.             FontUtilities.getLogger()
  345.                     .info("FC name=" + name + " style=" + style +
  346.                             " uses " + fcInfo.firstFont.familyName +
  347.                             " in file: " + fcInfo.firstFont.fontFile);
  348.         }
  349.  
  350.         if (fcInfo.compFont != null) {
  351.             return fcInfo.compFont;
  352.         }
  353.  
  354.         /* jdkFont is going to be used for slots 1..N and as a fallback.
  355.          * Slot 0 will be the physical font from fontconfig.
  356.          */
  357.         FontManager fm = FontManagerFactory.getInstance();
  358.         CompositeFont jdkFont = (CompositeFont)
  359.                 fm.findFont2D(fcInfo.jdkName, style, FontManager.LOGICAL_FALLBACK);
  360.  
  361.         if (fcInfo.firstFont.familyName == null ||
  362.                 fcInfo.firstFont.fontFile == null) {
  363.             return (fcInfo.compFont = jdkFont);
  364.         }
  365.  
  366.         /* First, see if the family and exact style is already registered.
  367.          * If it is, use it. If it's not, then try to register it.
  368.          * If that registration fails (signalled by null) just return the
  369.          * regular JDK composite.
  370.          * Algorithmically styled fonts won't match on exact style, so
  371.          * will fall through this code, but the regisration code will
  372.          * find that file already registered and return its font.
  373.          */
  374.         FontFamily family = FontFamily.getFamily(fcInfo.firstFont.familyName);
  375.         PhysicalFont physFont = null;
  376.         if (family != null) {
  377.             Font2D f2D = family.getFontWithExactStyleMatch(fcInfo.style);
  378.             if (f2D instanceof PhysicalFont) {
  379.                 physFont = (PhysicalFont)f2D;
  380.             }
  381.         }
  382.  
  383.         if (physFont == null ||
  384.                 !fcInfo.firstFont.fontFile.equals(physFont.platName)) {
  385.             physFont = registerFromFcInfo(fcInfo);
  386.             if (physFont == null) {
  387.                 return (fcInfo.compFont = jdkFont);
  388.             }
  389.             family = FontFamily.getFamily(physFont.getFamilyName(null));
  390.         }
  391.  
  392.         /* Now register the fonts in the family (the other styles) after
  393.          * checking that they aren't already registered and are actually in
  394.          * a different file. They may be the same file in CJK cases.
  395.          * For cases where they are different font files - eg as is common for
  396.          * Latin fonts, then we rely on fontconfig to report these correctly.
  397.          * Assume that all styles of this font are found by fontconfig,
  398.          * so we can find all the family members which must be registered
  399.          * together to prevent synthetic styling.
  400.          */
  401.         for (int i=0; i<fontConfigFonts.length; i++) {
  402.             FcCompFont fc = fontConfigFonts[i];
  403.             if (fc != fcInfo &&
  404.                     physFont.getFamilyName(null).equals(fc.firstFont.familyName) &&
  405.                     !fc.firstFont.fontFile.equals(physFont.platName) &&
  406.                     family.getFontWithExactStyleMatch(fc.style) == null) {
  407.  
  408.                 registerFromFcInfo(fontConfigFonts[i]);
  409.             }
  410.         }
  411.  
  412.         /* Now we have a physical font. We will back this up with the JDK
  413.          * logical font (sansserif, serif, or monospaced) that corresponds
  414.          * to the Pango/GTK/FC logical font name.
  415.          */
  416.         return (fcInfo.compFont = new CompositeFont(physFont, jdkFont));
  417.     }
  418.  
  419.     /**
  420.      *
  421.      * @param locale
  422.      * @param fcFamily
  423.      * @return
  424.      */
  425.     public FcCompFont[] getFontConfigFonts() {
  426.         return fontConfigFonts;
  427.     }
  428.  
  429.     /* Return an array of FcCompFont structs describing the primary
  430.      * font located for each of fontconfig/GTK/Pango's logical font names.
  431.      */
  432.     private static native void getFontConfig(String locale,
  433.                                              FontConfigInfo fcInfo,
  434.                                              FcCompFont[] fonts,
  435.                                              boolean includeFallbacks);
  436.  
  437.     void populateFontConfig(FcCompFont[] fcInfo) {
  438.         fontConfigFonts = fcInfo;
  439.     }
  440.  
  441.     FcCompFont[] loadFontConfig() {
  442.         initFontConfigFonts(true);
  443.         return fontConfigFonts;
  444.     }
  445.  
  446.     FontConfigInfo getFontConfigInfo() {
  447.         initFontConfigFonts(true);
  448.         return fcInfo;
  449.     }
  450.  
  451.     private static native int
  452.     getFontConfigAASettings(String locale, String fcFamily);
  453. }


————————————————
版权声明：本文为CSDN博主「神韵499」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41055045/article/details/112002440

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/442199
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号