com.aspose.words

Class FontSubstitutionSettings

  • java.lang.Object
    • com.aspose.words.FontSubstitutionSettings
public class FontSubstitutionSettings 
extends java.lang.Object

Specifies font substitution mechanism settings.

Font substitution process consists of several rules which are checked one by one in specific order. If the first rule can't resolve the font then second rule is checked and so on.

The order of the rules is following: 1. Font name substitution rule (enabled by default) 2. Font config substitution rule (disabled by default) 3. Table substitution rule (enabled by default) 4. Font info substitution rule (enabled by default) 5. Default font rule (enabled by default)

Note that font info substitution rule will always resolve the font if FontInfo is available and will override the default font rule. If you want to use the default font rule then you should disable the font info substitution rule.

Note that font config substitution rule will resolve the font in most cases and thus overrides all other rules.

Example:

Shows how to access a document's system font source and set font substitutes.
Document doc = new Document();
doc.setFontSettings(new FontSettings());

// By default, a blank document always contains a system font source.
Assert.assertEquals(1, doc.getFontSettings().getFontsSources().length);

SystemFontSource systemFontSource = (SystemFontSource) doc.getFontSettings().getFontsSources()[0];
Assert.assertEquals(FontSourceType.SYSTEM_FONTS, systemFontSource.getType());
Assert.assertEquals(0, systemFontSource.getPriority());

if (SystemUtils.IS_OS_WINDOWS) {
    final String FONTS_PATH = "C:\\WINDOWS\\Fonts";
    Assert.assertEquals(FONTS_PATH.toLowerCase(), SystemFontSource.getSystemFontFolders()[0].toLowerCase());
}

for (String systemFontFolder : SystemFontSource.getSystemFontFolders()) {
    System.out.println(systemFontFolder);
}

// Set a font that exists in the Windows Fonts directory as a substitute for one that does not.
doc.getFontSettings().getSubstitutionSettings().getFontInfoSubstitution().setEnabled(true);
doc.getFontSettings().getSubstitutionSettings().getTableSubstitution().addSubstitutes("Kreon-Regular", "Calibri");

Assert.assertEquals(1, IterableUtils.size(doc.getFontSettings().getSubstitutionSettings().getTableSubstitution().getSubstitutes("Kreon-Regular")));
Assert.assertTrue(IterableUtils.toString(doc.getFontSettings().getSubstitutionSettings().getTableSubstitution().getSubstitutes("Kreon-Regular")).contains("Calibri"));

// Alternatively, we could add a folder font source in which the corresponding folder contains the font.
FolderFontSource folderFontSource = new FolderFontSource(getFontsDir(), false);
doc.getFontSettings().setFontsSources(new FontSourceBase[]{systemFontSource, folderFontSource});
Assert.assertEquals(2, doc.getFontSettings().getFontsSources().length);

// Resetting the font sources still leaves us with the system font source as well as our substitutes.
doc.getFontSettings().resetFontSources();

Assert.assertEquals(1, doc.getFontSettings().getFontsSources().length);
Assert.assertEquals(FontSourceType.SYSTEM_FONTS, doc.getFontSettings().getFontsSources()[0].getType());
Assert.assertEquals(1, IterableUtils.size(doc.getFontSettings().getSubstitutionSettings().getTableSubstitution().getSubstitutes("Kreon-Regular")));

Property Getters/Setters Summary
DefaultFontSubstitutionRulegetDefaultFontSubstitution()
Settings related to default font substitution rule.
FontConfigSubstitutionRulegetFontConfigSubstitution()
Settings related to font config substitution rule.
FontInfoSubstitutionRulegetFontInfoSubstitution()
Settings related to font info substitution rule.
FontNameSubstitutionRulegetFontNameSubstitution()
Settings related to font name substitution rule.
TableSubstitutionRulegetTableSubstitution()
Settings related to table substitution rule.
 

    • Property Getters/Setters Detail

      • getDefaultFontSubstitution

        public DefaultFontSubstitutionRule getDefaultFontSubstitution()
        
        Settings related to default font substitution rule.

        Example:

        Shows how to set the default font substitution rule.
        Document doc = new Document();
        FontSettings fontSettings = new FontSettings();
        doc.setFontSettings(fontSettings);
        
        // Get the default substitution rule within FontSettings.
        // This rule will substitute all missing fonts with "Times New Roman".
        DefaultFontSubstitutionRule defaultFontSubstitutionRule = fontSettings.getSubstitutionSettings().getDefaultFontSubstitution();
        Assert.assertTrue(defaultFontSubstitutionRule.getEnabled());
        Assert.assertEquals("Times New Roman", defaultFontSubstitutionRule.getDefaultFontName());
        
        // Set the default font substitute to "Courier New".
        defaultFontSubstitutionRule.setDefaultFontName("Courier New");
        
        // Using a document builder, add some text in a font that we do not have to see the substitution take place,
        // and then render the result in a PDF.
        DocumentBuilder builder = new DocumentBuilder(doc);
        
        builder.getFont().setName("Missing Font");
        builder.writeln("Line written in a missing font, which will be substituted with Courier New.");
        
        doc.save(getArtifactsDir() + "FontSettings.DefaultFontSubstitutionRule.pdf");
      • getFontConfigSubstitution

        public FontConfigSubstitutionRule getFontConfigSubstitution()
        
        Settings related to font config substitution rule.

        Example:

        Shows operating system-dependent font config substitution.
        FontSettings fontSettings = new FontSettings();
        FontConfigSubstitutionRule fontConfigSubstitution = fontSettings.getSubstitutionSettings().getFontConfigSubstitution();
        
        // The FontConfigSubstitutionRule object works differently on Windows/non-Windows platforms.
        // On Windows, it is unavailable.
        if (SystemUtils.IS_OS_WINDOWS) {
            Assert.assertFalse(fontConfigSubstitution.getEnabled());
            Assert.assertFalse(fontConfigSubstitution.isFontConfigAvailable());
        }
        
        // On Linux/Mac, we will have access to it, and will be able to perform operations.
        if (SystemUtils.IS_OS_LINUX) {
            Assert.assertTrue(fontConfigSubstitution.getEnabled());
            Assert.assertTrue(fontConfigSubstitution.isFontConfigAvailable());
        
            fontConfigSubstitution.resetCache();
        }
      • getFontInfoSubstitution

        public FontInfoSubstitutionRule getFontInfoSubstitution()
        
        Settings related to font info substitution rule.

        Example:

        Shows how to set the property for finding the closest match for a missing font from the available font sources.
        @Test
        public void enableFontSubstitution() throws Exception {
            // Open a document that contains text formatted with a font that does not exist in any of our font sources.
            Document doc = new Document(getMyDir() + "Missing font.docx");
        
            // Assign a callback for handling font substitution warnings.
            HandleDocumentSubstitutionWarnings substitutionWarningHandler = new HandleDocumentSubstitutionWarnings();
            doc.setWarningCallback(substitutionWarningHandler);
        
            // Set a default font name and enable font substitution.
            FontSettings fontSettings = new FontSettings();
            fontSettings.getSubstitutionSettings().getDefaultFontSubstitution().setDefaultFontName("Arial");
            fontSettings.getSubstitutionSettings().getFontInfoSubstitution().setEnabled(true);
        
            // We will get a font substitution warning if we save a document with a missing font.
            doc.setFontSettings(fontSettings);
            doc.save(getArtifactsDir() + "FontSettings.EnableFontSubstitution.pdf");
        
            Iterator<WarningInfo> warnings = substitutionWarningHandler.FontWarnings.iterator();
        
            while (warnings.hasNext())
                System.out.println(warnings.next().getDescription());
        
            // We can also verify warnings in the collection and clear them.
            Assert.assertEquals(WarningSource.LAYOUT, substitutionWarningHandler.FontWarnings.get(0).getSource());
            Assert.assertEquals("Font '28 Days Later' has not been found. Using 'Calibri' font instead. Reason: alternative name from document.",
                    substitutionWarningHandler.FontWarnings.get(0).getDescription());
        
            substitutionWarningHandler.FontWarnings.clear();
        
            Assert.assertTrue(substitutionWarningHandler.FontWarnings.getCount() == 0);
        }
        
        public static class HandleDocumentSubstitutionWarnings implements IWarningCallback {
            /// <summary>
            /// Called every time a warning occurs during loading/saving.
            /// </summary>
            public void warning(WarningInfo info) {
                if (info.getWarningType() == WarningType.FONT_SUBSTITUTION)
                    FontWarnings.warning(info);
            }
        
            public WarningInfoCollection FontWarnings = new WarningInfoCollection();
        }
      • getFontNameSubstitution

        public FontNameSubstitutionRule getFontNameSubstitution()
        
        Settings related to font name substitution rule.
      • getTableSubstitution

        public TableSubstitutionRule getTableSubstitution()
        
        Settings related to table substitution rule.

        Example:

        Shows how to work with custom font substitution tables.
        Document doc = new Document();
        FontSettings fontSettings = new FontSettings();
        doc.setFontSettings(fontSettings);
        
        // Create a new table substitution rule and load the default Windows font substitution table.
        TableSubstitutionRule tableSubstitutionRule = fontSettings.getSubstitutionSettings().getTableSubstitution();
        
        // If we select fonts exclusively from our folder, we will need a custom substitution table.
        // We will no longer have access to the Microsoft Windows fonts,
        // such as "Arial" or "Times New Roman" since they do not exist in our new font folder.
        FolderFontSource folderFontSource = new FolderFontSource(getFontsDir(), false);
        fontSettings.setFontsSources(new FontSourceBase[]{folderFontSource});
        
        // Below are two ways of loading a substitution table from a file in the local file system.
        // 1 -  From a stream:
        try (FileInputStream fileStream = new FileInputStream(getMyDir() + "Font substitution rules.xml")) {
            tableSubstitutionRule.load(fileStream);
        }
        
        // 2 -  Directly from a file:
        tableSubstitutionRule.load(getMyDir() + "Font substitution rules.xml");
        
        // Since we no longer have access to "Arial", our font table will first try substitute it with "Nonexistent Font".
        // We do not have this font so that it will move onto the next substitute, "Kreon", found in the "MyFonts" folder.
        Assert.assertEquals(new String[]{"Missing Font", "Kreon"}, IterableUtils.toList(tableSubstitutionRule.getSubstitutes("Arial")).toArray());
        
        // We can expand this table programmatically. We will add an entry that substitutes "Times New Roman" with "Arvo"
        Assert.assertNull(tableSubstitutionRule.getSubstitutes("Times New Roman"));
        tableSubstitutionRule.addSubstitutes("Times New Roman", "Arvo");
        Assert.assertEquals(new String[]{"Arvo"}, IterableUtils.toList(tableSubstitutionRule.getSubstitutes("Times New Roman")).toArray());
        
        // We can add a secondary fallback substitute for an existing font entry with AddSubstitutes().
        // In case "Arvo" is unavailable, our table will look for "M+ 2m" as a second substitute option.
        tableSubstitutionRule.addSubstitutes("Times New Roman", "M+ 2m");
        Assert.assertEquals(new String[]{"Arvo", "M+ 2m"}, IterableUtils.toList(tableSubstitutionRule.getSubstitutes("Times New Roman")).toArray());
        
        // SetSubstitutes() can set a new list of substitute fonts for a font.
        tableSubstitutionRule.setSubstitutes("Times New Roman", "Squarish Sans CT", "M+ 2m");
        Assert.assertEquals(new String[]{"Squarish Sans CT", "M+ 2m"}, IterableUtils.toList(tableSubstitutionRule.getSubstitutes("Times New Roman")).toArray());
        
        // Writing text in fonts that we do not have access to will invoke our substitution rules.
        DocumentBuilder builder = new DocumentBuilder(doc);
        builder.getFont().setName("Arial");
        builder.writeln("Text written in Arial, to be substituted by Kreon.");
        
        builder.getFont().setName("Times New Roman");
        builder.writeln("Text written in Times New Roman, to be substituted by Squarish Sans CT.");
        
        doc.save(getArtifactsDir() + "FontSettings.TableSubstitutionRule.Custom.pdf");