拼写检查器

本文介绍如何配置拼写检查语言、向自定义词典中添加或移除单词、禁用拼写检查等内容。

默认情况下，拼写检查功能是启用状态。拼写检查器会分析文本内容，并高亮显示所有拼写错误的单词。拼写检查器与配置文件（Profile）相关联。要访问并配置特定 Profile 的拼写检查器，请使用 SpellChecker 类：

Java
Kotlin
var spellChecker = profile.spellChecker();

val spellChecker = profile.spellChecker()

要禁用拼写检查，请使用 disable() 方法：

Java
Kotlin
profile.spellChecker().disable();

profile.spellChecker().disable()

另一种方法是使用 Engine.spellChecker() 方法，它会返回与默认 Profile 关联的 SpellChecker 类实例。

与 Windows 和 Linux 不同，在 macOS 上，Chromium 使用操作系统提供的拼写检查设置和词典。因此，正如您将在本指南中看到的，SpellChecker 服务在 macOS 上的行为有所不同。

语言 

拼写检查器可以在同一个网页上检查多种语言的文本。在 Windows 和 Linux 上，Chromium 会自动从其服务器下载词典文件，并将其存储在用户数据目录中。在 macOS 上，Chromium 使用操作系统提供的词典。

拼写检查语言及其对应词典的配置会保存在用户数据中。当你将 Engine 指向某个特定的用户数据目录时，这些设置会被保留，并在下次创建时重新加载相应的词典。

使用 SpellChecker.languages() 方法列出用于拼写检查的语言：

Java
Kotlin
var languages = spellChecker.languages();
for (var language : languages) {
    var code = language.code();
    var region = language.region();
}

val languages = spellChecker.languages()
for (language in languages) {
    val code = language.code()
    val region = language.region()
}

添加语言 

使用 SpellChecker.addLanguage(Language) 方法添加新的拼写检查语言：

Java
Kotlin
spellChecker.addLanguage(Language.CHINESE);
spellChecker.addLanguage(Language.of("en", "au"));

spellChecker.addLanguage(Language.CHINESE)
spellChecker.addLanguage(Language.of("en", "au"))

如果 Chromium 找不到所需词典，此方法会抛出 LanguageNotAvailableException。

在 macOS 上，此方法仅检查操作系统中是否提供所需词典。

移除语言 

在 Windows 和 Linux 上，使用 SpellChecker.removeLanguage(Language) 方法停止对某种特定语言的拼写检查：

Java
Kotlin
spellChecker.removeLanguage(Language.of("en", "au"));

spellChecker.removeLanguage(Language.of("en", "au"))

在 macOS 上，此方法不起作用。

自定义词典 

拼写检查器支持使用自定义词典。你可以通过 SpellChecker.customDictionary() 方法访问自定义词典。

例如：

Java
Kotlin
var dictionary = spellChecker.customDictionary();

val dictionary = spellChecker.customDictionary()

你可以使用 add(…) 方法向自定义词典中添加单词，既可以逐个添加，也可以批量添加；对于多个单词，批量添加的效率更高。

Java
Kotlin
// 添加一个单词:
var success = dictionary.add("John");

// 一次添加多个单词：
var words = Set.of("Fuzio", "Jiku", "HARDWARE_ACCELERATED");
List<SanitationError> errors = dictionary.add(words);

//  添加一个单词：
 val success = dictionary.add("John")

// 一次添加多个单词：
val words = setOf("Fuzio", "Jiku", "HARDWARE_ACCELERATED")
val errors = dictionary.add(words)

单词必须为 UTF-8 编码，长度介于 1 到 99 字节之间，且不能包含前导或尾随的 ASCII 空白字符。

如需从自定义词典中移除单词，请使用 remove(String) 方法：

Java
Kotlin
var success = dictionary.remove("John");

val success = dictionary.remove("John")

要检查词典中是否包含某个单词，请使用 has(String) 方法：

Java
Kotlin
var isWordInDictionary = dictionary.has("John");

val isWordInDictionary = dictionary.has("John")

要获取自定义词典中存储的所有单词，请使用 words() 方法：

Java
Kotlin
Collection<String> words = dictionary.words();

val words: Collection<String> = dictionary.words()

禁用拼写检查 

默认情况下，拼写检查处于启用状态。要禁用它，请使用以下代码：

Java
Kotlin
spellChecker.disable();

spellChecker.disable()

上下文菜单 

当用户在已加载网页中的高亮拼写错误单词上右键单击时，你可以显示一个带建议项的上下文菜单。使用 ShowContextMenuCallback 回调来显示一个带建议项以及“添加到词典”菜单项的上下文菜单。

当鼠标指针位于拼写错误的单词上时，使用 Browser.replaceMisspelledWord(String) 可将其替换为某个建议词：

Java
Kotlin
browser.replaceMisspelledWord("Scrumdiddlyumptious");

browser.replaceMisspelledWord("Scrumdiddlyumptious")

Swing 

以下示例演示如何创建并显示一个包含建议项和添加到词典 (Add to Dictionary) 菜单项的 Swing 上下文菜单。使用此上下文菜单，你可以将拼写错误的单词替换为某个建议词，或者将其添加到自定义词典中。

Java
Kotlin
browser.set(ShowContextMenuCallback.class, (params, tell) ->
        invokeLater(() -> {
            var popupMenu = new JPopupMenu();
            popupMenu.addPopupMenuListener(new PopupMenuListener() {
                @Override
                public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
                }

                @Override
                public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
                }

                @Override
                public void popupMenuCanceled(PopupMenuEvent e) {
                    tell.close();
                }
            });

            // 添加建议菜单项。
            var spellCheckMenu = params.spellCheckMenu();
            var suggestions = spellCheckMenu.dictionarySuggestions();
            suggestions.forEach(suggestion -> {
                var menuItem = new JMenuItem(suggestion);
                menuItem.addActionListener(e -> {
                    browser.replaceMisspelledWord(suggestion);
                    tell.close();
                });
                popupMenu.add(menuItem);
            });

            // 如果需要，添加菜单分隔符。
            if (!suggestions.isEmpty()) {
                popupMenu.addSeparator();
            }

            // 添加 "添加到词典" 菜单项。
            var addToDictionary = new JMenuItem(
                    spellCheckMenu.addToDictionaryMenuItemText());
            addToDictionary.addActionListener(e -> {
                var dictionary = engine.spellChecker().customDictionary();
                dictionary.add(spellCheckMenu.misspelledWord());
                tell.close();
            });
            popupMenu.add(addToDictionary);

            // 在指定位置显示上下文菜单。
            var location = params.location();
            popupMenu.show(view, location.x(), location.y());
        }));

browser.register(ShowContextMenuCallback { params, tell ->
    SwingUtilities.invokeLater {
        val popupMenu = JPopupMenu()
        popupMenu.addPopupMenuListener(object : PopupMenuListener {
            override fun popupMenuWillBecomeVisible(e: PopupMenuEvent?) {
            }

            override fun popupMenuWillBecomeInvisible(e: PopupMenuEvent?) {
            }

            override fun popupMenuCanceled(e: PopupMenuEvent) {
                tell.close()
            }
        })

        // 添加建议菜单项。
        val spellCheckMenu = params.spellCheckMenu()
        val suggestions = spellCheckMenu.dictionarySuggestions()
        suggestions.forEach { suggestion ->
            val menuItem = JMenuItem(suggestion)
            menuItem.addActionListener {
                browser.replaceMisspelledWord(suggestion)
                tell.close()
            }
            popupMenu.add(menuItem)
        }

        // 如果需要，添加菜单分隔符。
        if (suggestions.isNotEmpty()) {
            popupMenu.addSeparator()
        }

        // 添加 "添加到词典" 菜单项。
        val addToDictionary = JMenuItem(spellCheckMenu.addToDictionaryMenuItemText())
        addToDictionary.addActionListener {
            val dictionary = engine.spellChecker().customDictionary()
            dictionary.add(spellCheckMenu.misspelledWord())
            tell.close()
        }
        popupMenu.add(addToDictionary)

        // 在指定位置显示上下文菜单。
        val location = params.location()
        popupMenu.show(view, location.x(), location.y())
    }
})

如果在拼写错误的单词上右键单击，将会显示以下上下文菜单： Swing 拼写检查器上下文菜单

JavaFX 

以下示例演示了如何创建并显示一个带建议项和 Add to Dictionary 菜单项的 JavaFX 上下文菜单。使用此上下文菜单，你可以将拼写错误的单词替换为某个建议词，或者将其添加到自定义词典中。

Java
Kotlin
browser.set(ShowContextMenuCallback.class, (params, tell) ->
        runLater(() -> {
            var contextMenu = new ContextMenu();
            contextMenu.setAutoHide(true);
            contextMenu.setOnHidden(event -> {
                if (!tell.isClosed()) {
                    tell.close();
                }
            });
            view.setOnMousePressed(event -> {
                if (contextMenu.isShowing()) {
                    contextMenu.hide();
                }
            });
            // 添加建议菜单项。
            var spellCheckMenu = params.spellCheckMenu();
            var suggestions = spellCheckMenu.dictionarySuggestions();
            suggestions.forEach(suggestion -> {
                var item = new MenuItem(suggestion);
                item.setOnAction(event -> {
                    browser.replaceMisspelledWord(suggestion);
                    tell.close();
                });
                contextMenu.getItems().add(item);
            });

            //如果需要，添加菜单分隔符。
            if (!suggestions.isEmpty()) {
                contextMenu.getItems().add(new SeparatorMenuItem());
            }

            // 添加 "Add to Dictionary" 菜单项。
            var addToDictionary = new MenuItem(
                    spellCheckMenu.addToDictionaryMenuItemText()
            );
            addToDictionary.setOnAction(event -> {
                var spellChecker = engine.spellChecker();
                var dictionary = spellChecker.customDictionary();
                dictionary.add(spellCheckMenu.misspelledWord());
                tell.close();
            });
            contextMenu.getItems().add(addToDictionary);

            // 在屏幕上的指定位置显示上下文菜单。
            var location = params.location();
            var locationOnScreen = view.localToScreen(location.x(), location.y());
            contextMenu.show(view, locationOnScreen.getX(), locationOnScreen.getY());
        }));

browser.register(ShowContextMenuCallback { params, tell ->
    Platform.runLater {
        val contextMenu = ContextMenu()
        contextMenu.isAutoHide = true
        contextMenu.setOnHidden {
            if (!tell.isClosed) {
                tell.close()
            }
        }
        view.setOnMousePressed {
            if (contextMenu.isShowing) {
                contextMenu.hide()
            }
        }
        // 添加建议菜单项。
        val spellCheckMenu = params.spellCheckMenu()
        val suggestions = spellCheckMenu.dictionarySuggestions()
        suggestions.forEach { suggestion ->
            val item = MenuItem(suggestion)
            item.setOnAction {
                browser.replaceMisspelledWord(suggestion)
                tell.close()
            }
            contextMenu.items.add(item)
        }

        // 如果需要，添加菜单分隔符。
        if (suggestions.isNotEmpty()) {
            contextMenu.items.add(SeparatorMenuItem())
        }

        // 添加 "Add to Dictionary" 菜单项。
        val addToDictionary = MenuItem(spellCheckMenu.addToDictionaryMenuItemText())
        addToDictionary.setOnAction {
            val spellChecker = engine.spellChecker()
            val dictionary = spellChecker.customDictionary()
            dictionary.add(spellCheckMenu.misspelledWord())
            tell.close()
        }
        contextMenu.items.add(addToDictionary)

        // 在屏幕上的指定位置显示上下文菜单。
        val location = params.location()
        val locationOnScreen = view.localToScreen(location.x().toDouble(), location.y().toDouble())
        contextMenu.show(view, locationOnScreen.getX(), locationOnScreen.getY())
    }
})

如果在拼写错误的单词上右键单击，将显示以下上下文菜单： JavaFX Spell Checker Context Menu

拼写检查器事件 

当已加载网页上的文本字段或文本区域获得焦点时，拼写检查器会自动检查文本并高亮显示拼写错误的单词。要在文本检查完成后接收通知，请使用 SpellCheckCompleted 事件。

例如：

Java
Kotlin
browser.on(SpellCheckCompleted.class, event -> {
    // 已检查的文本。
    var text = event.checkedText();
    // 拼写检查结果列表。
    event.results().forEach(spellCheckingResult -> {
        // 在已检查文本中，被拼写检查器认为是拼写错误的单词的第一个符号的位置。
        var location = spellCheckingResult.location();
        // 已检查文本中拼写错误单词的长度。
        var length = spellCheckingResult.length();
    });
});

browser.subscribe<SpellCheckCompleted> { event ->
    // 已检查的文本。
    val text = event.checkedText()
    // 拼写检查结果列表。
    event.results().forEach { spellCheckingResult ->
        // 在已检查文本中，被拼写检查器认为是拼写错误的单词的第一个符号的位置。
        val location = spellCheckingResult.location()
        // 已检查文本中拼写错误单词的长度。
        val length = spellCheckingResult.length()
    }
}
微信咨询

即库客服

微信公众号二维码

技术客服

微信公众号二维码