Changeset 11156 in josm for trunk/src/org/openstreetmap/josm/tools/PlatformHookWindows.java

Timestamp:

2016-10-24T12:42:06+02:00 (9 years ago)

Author:

bastiK

Message:

rework/simplify inheritance structure of PlatformHook

PlatformHookUnixoid is no longer base class of PlatformHookWindows
and PlatformHookOsx; move common methods to PlatformHook

File:

• trunk/src/org/openstreetmap/josm/tools/PlatformHookWindows.java (modified) (5 diffs)

trunk/src/org/openstreetmap/josm/tools/PlatformHookWindows.java

@@ -29 +29 @@
 
 import java.awt.GraphicsEnvironment;
+import java.io.BufferedWriter;
 import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.DirectoryStream;
 import java.nio.file.FileSystems;
@@ -51 +57 @@
 import java.util.List;
 import java.util.Locale;
+import java.util.Properties;
 
 import javax.swing.JOptionPane;
 
 import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.Preferences;
 
 /**
@@ -60 +68 @@
   * @since 1023
   */
-public class PlatformHookWindows extends PlatformHookUnixoid {
-
-    @Override
-    public void startupHook() {
-        // Do nothing
+public class PlatformHookWindows implements PlatformHook {
+
+    /**
+     * Simple data class to hold information about a font.
+     *
+     * Used for fontconfig.properties files.
+     */
+    public static class FontEntry {
+        /**
+         * The character subset. Basically a free identifier, but should be unique.
+         */
+        @Preferences.pref
+        public String charset;
+
+        /**
+         * Platform font name.
+         */
+        @Preferences.pref
+        @Preferences.writeExplicitly
+        public String name = "";
+
+        /**
+         * File name.
+         */
+        @Preferences.pref
+        @Preferences.writeExplicitly
+        public String file = "";
+
+        /**
+         * Constructs a new {@code FontEntry}.
+         */
+        public FontEntry() {
+        }
+
+        /**
+         * Constructs a new {@code FontEntry}.
+         * @param charset The character subset. Basically a free identifier, but should be unique
+         * @param name Platform font name
+         * @param file File name
+         */
+        public FontEntry(String charset, String name, String file) {
+            this.charset = charset;
+            this.name = name;
+            this.file = file;
+        }
     }
 
@@ -319 +367 @@
 
     @Override
-    public Collection<String> getInstalledFonts() {
+    public File getDefaultUserDataDirectory() {
+        // Use preferences directory by default
+        return Main.pref.getPreferencesDirectory();
+    }
+
+    /**
+     * <p>Add more fallback fonts to the Java runtime, in order to get
+     * support for more scripts.</p>
+     *
+     * <p>The font configuration in Java doesn't include some Indic scripts,
+     * even though MS Windows ships with fonts that cover these unicode ranges.</p>
+     *
+     * <p>To fix this, the fontconfig.properties template is copied to the JOSM
+     * cache folder. Then, the additional entries are added to the font
+     * configuration. Finally the system property "sun.awt.fontconfig" is set
+     * to the customized fontconfig.properties file.</p>
+     *
+     * <p>This is a crude hack, but better than no font display at all for these languages.
+     * There is no guarantee, that the template file
+     * ($JAVA_HOME/lib/fontconfig.properties.src) matches the default
+     * configuration (which is in a binary format).
+     * Furthermore, the system property "sun.awt.fontconfig" is undocumented and
+     * may no longer work in future versions of Java.</p>
+     *
+     * <p>Related Java bug: <a href="https://bugs.openjdk.java.net/browse/JDK-8008572">JDK-8008572</a></p>
+     *
+     * @param templateFileName file name of the fontconfig.properties template file
+     */
+    protected void extendFontconfig(String templateFileName) {
+        String customFontconfigFile = Main.pref.get("fontconfig.properties", null);
+        if (customFontconfigFile != null) {
+            Utils.updateSystemProperty("sun.awt.fontconfig", customFontconfigFile);
+            return;
+        }
+        if (!Main.pref.getBoolean("font.extended-unicode", true))
+            return;
+
+        String javaLibPath = System.getProperty("java.home") + File.separator + "lib";
+        Path templateFile = FileSystems.getDefault().getPath(javaLibPath, templateFileName);
+        if (!Files.isReadable(templateFile)) {
+            Main.warn("extended font config - unable to find font config template file "+templateFile.toString());
+            return;
+        }
+        try (FileInputStream fis = new FileInputStream(templateFile.toFile())) {
+            Properties props = new Properties();
+            props.load(fis);
+            byte[] content = Files.readAllBytes(templateFile);
+            File cachePath = Main.pref.getCacheDirectory();
+            Path fontconfigFile = cachePath.toPath().resolve("fontconfig.properties");
+            OutputStream os = Files.newOutputStream(fontconfigFile);
+            os.write(content);
+            try (Writer w = new BufferedWriter(new OutputStreamWriter(os, StandardCharsets.UTF_8))) {
+                Collection<FontEntry> extrasPref = Main.pref.getListOfStructs(
+                        "font.extended-unicode.extra-items", getAdditionalFonts(), FontEntry.class);
+                Collection<FontEntry> extras = new ArrayList<>();
+                w.append("\n\n# Added by JOSM to extend unicode coverage of Java font support:\n\n");
+                List<String> allCharSubsets = new ArrayList<>();
+                for (FontEntry entry: extrasPref) {
+                    Collection<String> fontsAvail = getInstalledFonts();
+                    if (fontsAvail != null && fontsAvail.contains(entry.file.toUpperCase(Locale.ENGLISH))) {
+                        if (!allCharSubsets.contains(entry.charset)) {
+                            allCharSubsets.add(entry.charset);
+                            extras.add(entry);
+                        } else {
+                            Main.trace("extended font config - already registered font for charset ''{0}'' - skipping ''{1}''",
+                                    entry.charset, entry.name);
+                        }
+                    } else {
+                        Main.trace("extended font config - Font ''{0}'' not found on system - skipping", entry.name);
+                    }
+                }
+                for (FontEntry entry: extras) {
+                    allCharSubsets.add(entry.charset);
+                    if ("".equals(entry.name)) {
+                        continue;
+                    }
+                    String key = "allfonts." + entry.charset;
+                    String value = entry.name;
+                    String prevValue = props.getProperty(key);
+                    if (prevValue != null && !prevValue.equals(value)) {
+                        Main.warn("extended font config - overriding ''{0}={1}'' with ''{2}''", key, prevValue, value);
+                    }
+                    w.append(key + '=' + value + '\n');
+                }
+                w.append('\n');
+                for (FontEntry entry: extras) {
+                    if ("".equals(entry.name) || "".equals(entry.file)) {
+                        continue;
+                    }
+                    String key = "filename." + entry.name.replace(' ', '_');
+                    String value = entry.file;
+                    String prevValue = props.getProperty(key);
+                    if (prevValue != null && !prevValue.equals(value)) {
+                        Main.warn("extended font config - overriding ''{0}={1}'' with ''{2}''", key, prevValue, value);
+                    }
+                    w.append(key + '=' + value + '\n');
+                }
+                w.append('\n');
+                String fallback = props.getProperty("sequence.fallback");
+                if (fallback != null) {
+                    w.append("sequence.fallback=" + fallback + ',' + Utils.join(",", allCharSubsets) + '\n');
+                } else {
+                    w.append("sequence.fallback=" + Utils.join(",", allCharSubsets) + '\n');
+                }
+            }
+            Utils.updateSystemProperty("sun.awt.fontconfig", fontconfigFile.toString());
+        } catch (IOException ex) {
+            Main.error(ex);
+        }
+    }
+
+    /**
+     * Get a list of fonts that are installed on the system.
+     *
+     * Must be done without triggering the Java Font initialization.
+     * (See {@link #extendFontconfig(java.lang.String)}, have to set system
+     * property first, which is then read by sun.awt.FontConfiguration upon initialization.)
+     *
+     * @return list of file names
+     */
+    protected Collection<String> getInstalledFonts() {
         // Cannot use GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames()
         // because we have to set the system property before Java initializes its fonts.
@@ -341 +509 @@
     }
 
-    @Override
-    public Collection<FontEntry> getAdditionalFonts() {
+    /**
+     * Get default list of additional fonts to add to the configuration.
+     *
+     * Java will choose thee first font in the list that can render a certain character.
+     *
+     * @return list of FontEntry objects
+     */
+    protected Collection<FontEntry> getAdditionalFonts() {
         Collection<FontEntry> def = new ArrayList<>(33);
         def.add(new FontEntry("devanagari", "", "")); // just include in fallback list font already defined in template