Guias

List icon Conteúdo
Close
Introdução
Guias

Corretor ortográfico

Este documento descreve como configurar a verificação ortográfica com os dicionários necessários, adicionar ou remover palavras de um dicionário personalizado, desativar a verificação ortográfica e muito mais.

Por padrão, a verificação ortográfica está ativada e configurada para utilizar o dicionário en-US. O corretor ortográfico analisa o texto em todos os campos de texto, bem como as áreas de texto, na página Web carregada e destaca todas as palavras com erros ortográficos. O serviço de correção ortográfica está associado a perfis. Para acessar e configurar o corretor ortográfico para o Profile específico, utilize a interface ISpellChecker:

ISpellChecker spellChecker = profile.SpellChecker;

Dim spellChecker As ISpellChecker = profile.SpellChecker

Outra opção é utilizar a propriedade Engine.Profiles.Default.SpellChecker que devolve a instância do serviço ISpellChecker associado ao perfil predefinido.

Adicionando idiomas

O corretor ortográfico pode verificar o texto em diferentes línguas numa única página Web. Para configurar o idioma necessário, utilize o método spellChecker.Languages.Add(). O Chromium baixa automaticamente os arquivos de dicionário dos seus servidores Web.

spellChecker.Languages.Add(Language.EnglishUs);

spellChecker.Languages.Add(Language.EnglishUs)

Se o Chromium não conseguir encontrar o dicionário necessário, será lançada a LanguageNotAvailableException.

A configuração e os dicionários de línguas são armazenados na pasta user data. Se você configurar o IEngine para utilizar uma pasta de dados do usuário específica, este vai se lembrar das definições de idioma e vai restaurar elas da próxima vez.

Para esperar até que a língua correspondente seja descarregada do diretório de dados do utilizador, utilize o seguinte código:

spellChecker.Languages.Add(Language.EnglishUs).Wait();

spellChecker.Languages.Add(Language.EnglishUs).Wait()

Removendo idiomas

Utilize o método spellChecker.Languages.Remove() para interromper a verificação ortográfica de um determinado idioma:

spellChecker.Languages.Remove(Language.EnglishUs);

spellChecker.Languages.Remove(Language.EnglishUs)

Obter idiomas

Para obter a lista de línguas utilizadas para a correção ortográfica, utilize o seguinte código:

ISpellChecker spellChecker = Engine.Profiles.Default.SpellChecker;
IReadOnlyList<Language> languages = spellChecker.Languages.All;

Dim spellChecker As ISpellChecker = Engine.Profiles.Default.SpellChecker
Dim languages As IReadOnlyList(Of Language) = spellChecker.Languages.All

Dicionário personalizado

O corretor ortográfico suporta o dicionário personalizado. Você consegue acessar um dicionário personalizado utilizando a propriedade SpellChecker.CustomDictionary.

Por exemplo:

ISpellCheckDictionary dictionary = spellChecker.CustomDictionary;

Dim dictionary As ISpellCheckDictionary = spellChecker.CustomDictionary

Adicionando uma palavra

Você pode adicionar palavras ao dicionário personalizado utilizando o método Add(string):

bool success = dictionary.Add("John");

Dim success As Boolean = dictionary.Add("John")

O DotNetBrowser tem os seguintes requisitos para as palavras adicionadas ao dicionário personalizado: - codificação de palavras UTF-8; - comprimento da palavra entre 1 e 99 bytes; - sem espaços em branco ASCII à esquerda ou à direita.

Removendo uma palavra

Para remover uma palavra do dicionário personalizado, utilize o método Remove(string) , conforme mostrado no exemplo de código abaixo:

bool success = dictionary.Remove("John");

Dim success As Boolean = dictionary.Remove("John")

Desativando a verificação ortográfica

Por predefinição, a verificação ortográfica está ativada. Você pode desativá-la utilizando o exemplo de código abaixo:

spellChecker.Enabled = false;

spellChecker.Enabled = False

É possível apresentar um menu de contexto com sugestões quando um usuário clica com o botão direito do mouse na palavra destacada com erro ortográfico na página Web carregada. Utilize o IBrowser.ShowContextMenuHandler para apresentar o menu de contexto com sugestões e um item de menu para adicionar a palavra mal escrita ao dicionário personalizado.

WinForms

O exemplo de código abaixo demonstra como criar e exibir o menu de contexto do WinForms com sugestões e o item de menu Adicionar ao dicionário. Utilizando este menu de contexto, você pode substituir a palavra mal escrita por uma das sugestões ou adicioná-la ao dicionário personalizado.

browser.ShowContextMenuHandler =
    new AsyncHandler<ShowContextMenuParameters,
        ShowContextMenuResponse>(ShowMenu);

browser.ShowContextMenuHandler =
     New AsyncHandler (Of ShowContextMenuParameters, ShowContextMenuResponse)(
         AddressOf ShowMenu)

private ToolStripItem BuildMenuItem(string item, bool isEnabled,
                                    EventHandler clickHandler)
{
    ToolStripItem result = new ToolStripMenuItem
    {
        Text = item,
        Enabled = isEnabled
    };
    result.Click += clickHandler;

    return result;
}

private Task<ShowContextMenuResponse> ShowMenu(ShowContextMenuParameters parameters)
{
    TaskCompletionSource<ShowContextMenuResponse> tcs =
        new TaskCompletionSource<ShowContextMenuResponse>();

    SpellCheckMenu spellCheckMenu = parameters.SpellCheckMenu;
    if (spellCheckMenu != null)
    {
        BeginInvoke(new Action(() =>
        {
            ContextMenuStrip popupMenu = new ContextMenuStrip();
            IEnumerable<string> suggestions = spellCheckMenu.DictionarySuggestions;
            if (suggestions != null)
            {
                // Adiciona items de meu com sugestões.
                foreach (string suggestion in suggestions)
                {
                    popupMenu.Items.Add(BuildMenuItem(suggestion, true, delegate
                    {
                        browser.ReplaceMisspelledWord(suggestion);
                        tcs.TrySetResult(ShowContextMenuResponse.Close());
                    }));
                }
            }

            // Adiciona o item de menu "Adicionar ao dicionário".
            string addToDictionary =
                spellCheckMenu.AddToDictionaryMenuItemText ?? "Adicionar ao Dicionário";

            popupMenu.Items.Add(BuildMenuItem(addToDictionary, true, delegate
            {
                if (!string.IsNullOrWhiteSpace(spellCheckMenu.MisspelledWord))
                {
                    engine.Profiles.Default.SpellChecker?.CustomDictionary
                         ?.Add(spellCheckMenu.MisspelledWord);
                }

                tcs.TrySetResult(ShowContextMenuResponse.Close());
            }));

            // Fecha o menu de contexto quando o navegador pede o foco de volta.
            EventHandler<FocusRequestedEventArgs> onFocusRequested = null;
            onFocusRequested = (sender, args) =>
            {
                BeginInvoke((Action) (() => popupMenu.Close()));
                parameters.Browser.FocusRequested -= onFocusRequested;
            };
            parameters.Browser.FocusRequested += onFocusRequested;

            // Trata o evento de fechamento do menu.
            ToolStripDropDownClosedEventHandler menuOnClosed = null;
            menuOnClosed = (sender, args) =>
            {
                bool itemNotClicked =
                    args.CloseReason != ToolStripDropDownCloseReason.ItemClicked;
                if (itemNotClicked)
                {
                    tcs.TrySetResult(ShowContextMenuResponse.Close());
                }

                popupMenu.Closed -= menuOnClosed;
            };
            popupMenu.Closed += menuOnClosed;

            // Mostra o menu de contexto.
            Point location = new Point(parameters.Location.X, parameters.Location.Y);
            popupMenu.Show(this, location);
            tcs.TrySetResult(ShowContextMenuResponse.Close());
        }));
    }
    else
    {
        tcs.TrySetResult(ShowContextMenuResponse.Close());
    }

    return tcs.Task;
}

Private Function BuildMenuItem(item As String, isEnabled As Boolean,
                               clickHandler As EventHandler) As ToolStripItem
    Dim result As ToolStripItem = New ToolStripMenuItem With {
        .Text = item,
        .Enabled = isEnabled
    }
    AddHandler result.Click, clickHandler

    Return result
End Function

Private Function ShowMenu(parameters As ShowContextMenuParameters) _
    As Task(Of ShowContextMenuResponse)

    Dim tcs As New TaskCompletionSource(Of ShowContextMenuResponse)()
    Dim spellCheckMenu As SpellCheckMenu = parameters.SpellCheckMenu
    If spellCheckMenu IsNot Nothing Then
        BeginInvoke(New Action(Sub()
            Dim popupMenu As New ContextMenuStrip()
            Dim suggestions As IEnumerable(Of String) =
                    spellCheckMenu.DictionarySuggestions

            If suggestions IsNot Nothing Then
                ' Adiciona itens de menu com sugestões.
                For Each suggestion As String In suggestions
                    popupMenu.Items.Add(BuildMenuItem(suggestion, True, Sub()
                        browser.ReplaceMisspelledWord(suggestion)
                        tcs.TrySetResult(ShowContextMenuResponse.Close())
                    End Sub))
                Next suggestion
            End If

            ' Adiciona item de menu "Adicionar ao dicionário.
            Dim addToDictionary As String =
                If (spellCheckMenu.AddToDictionaryMenuItemText, "Adicionar ao dicionário")

            popupMenu.Items.Add(BuildMenuItem(addToDictionary, True, Sub()
                If Not String.IsNullOrWhiteSpace(spellCheckMenu.MisspelledWord) Then
                    engine.Profiles.Default.SpellChecker?.CustomDictionary? .Add(
                        spellCheckMenu.MisspelledWord)
                End If
                tcs.TrySetResult(ShowContextMenuResponse.Close())
            End Sub))

            ' Fechar o menu de contexto quando o browser voltar a pedir o foco.
            Dim onFocusRequested As EventHandler(Of FocusRequestedEventArgs) = Nothing
            onFocusRequested = Sub(sender, args)
                BeginInvoke(CType(Sub() popupMenu.Close(), Action))
                RemoveHandler parameters.Browser.FocusRequested, onFocusRequested
            End Sub
            AddHandler parameters.Browser.FocusRequested, onFocusRequested

            ' Trata o evento de fechamento do menu.
            Dim menuOnClosed As ToolStripDropDownClosedEventHandler = Nothing
            menuOnClosed = Sub(sender, args)
                Dim itemNotClicked As Boolean = args.CloseReason <>
                                                ToolStripDropDownCloseReason.ItemClicked

                If itemNotClicked Then
                    tcs.TrySetResult(ShowContextMenuResponse.Close())
                End If

                RemoveHandler popupMenu.Closed, menuOnClosed
            End Sub
            AddHandler popupMenu.Closed, menuOnClosed

            ' Mostra o menu de contexto.
            Dim location As New Point(parameters.Location.X, parameters.Location.Y)
            popupMenu.Show(Me, location)
            tcs.TrySetResult(ShowContextMenuResponse.Close())
        End Sub))
    Else
        tcs.TrySetResult(ShowContextMenuResponse.Close())
    End If
    Return tcs.Task
End Function

Se clicar com o botão direito do mouse numa palavra mal escrita, o menu de contexto aparece: Menu de contexto do verificador ortográfico do WinForms

O exemplo completo está disponível no nosso repositório: C#, VB.NET.

WPF

O exemplo de código abaixo demonstra como criar e exibir um menu de contexto do WPF com sugestões e o item de menu Adicionar ao dicionário. Utilizando este menu de contexto, pode substituir a palavra mal escrita por uma das sugestões ou adicioná-la ao dicionário personalizado.

browser.ShowContextMenuHandler =
    new AsyncHandler<ShowContextMenuParameters, 
                     ShowContextMenuResponse>(ShowContextMenu);

browser.ShowContextMenuHandler =
    New AsyncHandler(Of ShowContextMenuParameters, ShowContextMenuResponse)(
        AddressOf ShowContextMenu)

private Task<ShowContextMenuResponse> ShowContextMenu(
    ShowContextMenuParameters parameters)
{
    TaskCompletionSource<ShowContextMenuResponse> tcs =
        new TaskCompletionSource<ShowContextMenuResponse>();

    SpellCheckMenu spellCheckMenu = parameters.SpellCheckMenu;
    WebView.Dispatcher?.BeginInvoke(new Action(() =>
    {
        System.Windows.Controls.ContextMenu popupMenu =
            new System.Windows.Controls.ContextMenu();

        IEnumerable<string> suggestions = spellCheckMenu.DictionarySuggestions;
        if (suggestions != null)
        {
            // Adiciona itens de menu com sugestões.
            foreach (string suggestion in suggestions)
            {
                MenuItem menuItem =
                    BuildMenuItem(suggestion, true,
                                  delegate
                                  {
                                      browser.ReplaceMisspelledWord(suggestion);
                                      tcs.TrySetResult(ShowContextMenuResponse
                                                          .Close());
                                  });
                popupMenu.Items.Add(menuItem);
            }
        }

        // Adiciona o item de menu "Adicionar ao dicionário".
        string addToDictionary =
            spellCheckMenu.AddToDictionaryMenuItemText ?? "Adicionar ao Dicionário";

        popupMenu.Items.Add(BuildMenuItem(addToDictionary, true, delegate
        {
            if (!string.IsNullOrWhiteSpace(spellCheckMenu.MisspelledWord))
            {
                engine.Profiles.Default.SpellChecker?.CustomDictionary
                     ?.Add(spellCheckMenu.MisspelledWord);
            }

            tcs.TrySetResult(ShowContextMenuResponse.Close());
        }));

        popupMenu.Closed += (sender, args) =>
        {
            tcs.TrySetResult(ShowContextMenuResponse.Close());
        };

        popupMenu.IsOpen = true;
    }));
    return tcs.Task;
}

Private Function ShowContextMenu(parameters As ShowContextMenuParameters) _
    As Task(Of ShowContextMenuResponse)

    Dim tcs As New TaskCompletionSource(Of ShowContextMenuResponse)()
    Dim spellCheckMenu As SpellCheckMenu = parameters.SpellCheckMenu
    WebView.Dispatcher?.BeginInvoke(New Action(Sub()
        Dim popupMenu As New Controls.ContextMenu()

        Dim suggestions As IEnumerable(Of String) = spellCheckMenu.DictionarySuggestions
        If suggestions IsNot Nothing Then
            ' Adiciona itens de menu com sugestões.
            For Each suggestion As String In suggestions
                Dim menuItem As MenuItem = BuildMenuItem(suggestion, True, Sub()
                    browser.ReplaceMisspelledWord(suggestion)
                    tcs.TrySetResult(ShowContextMenuResponse.Close())
                End Sub)
                popupMenu.Items.Add(menuItem)
            Next suggestion
        End If

        ' Adiciona item de menu "Adicionar ao dicionário".
        Dim addToDictionary As String =
                If(spellCheckMenu.AddToDictionaryMenuItemText, "Adicionar ao Dicionário")

        popupMenu.Items.Add(BuildMenuItem(addToDictionary, True, Sub()
            If Not String.IsNullOrWhiteSpace(spellCheckMenu.MisspelledWord) Then
                engine.Profiles.Default.SpellChecker?.CustomDictionary?.Add(
                    spellCheckMenu.MisspelledWord)
            End If

            tcs.TrySetResult(ShowContextMenuResponse.Close())
        End Sub))
        AddHandler popupMenu.Closed, Sub(sender, args)
            tcs.TrySetResult(ShowContextMenuResponse.Close())
        End Sub

        popupMenu.IsOpen = True
    End Sub))
    Return tcs.Task
End Function

Se você clicar com o botão direito do mouse numa palavra mal escrita, o menu de contexto aparece: Menu de contexto do verificador ortográfico do WPF

Avalonia UI

O exemplo de código abaixo demonstra como criar e exibir o menu de contexto do Avalonia UI com sugestões e o item de menu Adicionar ao dicionário. Utilizando este menu de contexto, você pode substituir a palavra mal escrita por uma das sugestões ou adicioná-la ao dicionário personalizado.

browser.ShowContextMenuHandler =
    new AsyncHandler<ShowContextMenuParameters,
        ShowContextMenuResponse>(ShowContextMenu);

private Task<ShowContextMenuResponse> ShowContextMenu(
    ShowContextMenuParameters parameters)
{
    TaskCompletionSource<ShowContextMenuResponse> tcs =
        new TaskCompletionSource<ShowContextMenuResponse>();

    SpellCheckMenu spellCheckMenu = parameters.SpellCheckMenu;
    Dispatcher.UIThread.InvokeAsync(() =>
    {
        Avalonia.Controls.ContextMenu? cm = new();
        cm.Placement = PlacementMode.Pointer;
        Point point = new Point(parameters.Location.X, parameters.Location.Y);
        cm.PlacementRect = new Rect(point, new Size(1, 1));

        IEnumerable<string> suggestions = spellCheckMenu.DictionarySuggestions;
        if (suggestions != null)
        {
            // Add menu items with suggestions.
            foreach (string suggestion in suggestions)
            {
                MenuItem menuItem =
                    BuildMenuItem(suggestion, true, true,
                                  delegate
                                  {
                                      browser.ReplaceMisspelledWord(suggestion);
                                      tcs.TrySetResult(ShowContextMenuResponse
                                         .Close());
                                  });
                cm.Items.Add(menuItem);
            }
        }

        // Add "Add to Dictionary" menu item.
        string addToDictionary =
            spellCheckMenu.AddToDictionaryMenuItemText ?? "Add to Dictionary";

        cm.Items.Add(BuildMenuItem(addToDictionary, true, true, delegate
        {
            if (!string.IsNullOrWhiteSpace(spellCheckMenu.MisspelledWord))
            {
                engine.Profiles.Default.SpellChecker?.CustomDictionary
                     ?.Add(spellCheckMenu.MisspelledWord);
            }

            tcs.TrySetResult(ShowContextMenuResponse.Close());
        }));

        cm.Closed += (s, a) => tcs.TrySetResult(ShowContextMenuResponse.Close());
        cm.Open(BrowserView);
    });
    return tcs.Task;
}

Se clicar com o botão direito do mouse numa palavra mal escrita, o menu de contexto aparece: Avalonia Spell Checker Context Menu

Eventos do corretor ortográfico

Quando um campo de texto ou área de texto na página Web carregada está em foco, o corretor ortográfico verifica automaticamente o texto e destaca as palavras mal escritas. Para receber notificações quando o texto tiver sido verificado, utilize o evento IBrowser.SpellCheckCompleted, conforme mostrado no exemplo de código abaixo:

browser.SpellCheckCompleted += (s, e) => 
{
    // O texto que foi verificado.
    string text = e.CheckedText;
    // A lista dos resultados da verificação ortográfica.
    foreach(SpellCheckingResult spellCheckingResult in e.Results)
    {
        // A localização do primeiro símbolo na palavra mal escrita 
        // no texto verificado que é considerado como mal escrito 
        // pelo corretor ortográfico.
        uint location = spellCheckingResult.Location;
        // O comprimento da palavra mal escrita no texto verificado.
        uint length = spellCheckingResult.Length;
    }
};

AddHandler browser.SpellCheckCompleted, Sub(s, e)
    ' O texto que foi verificado.
    Dim text As String = e.CheckedText
    ' A lista dos resultados da verificação ortográfica.
    For Each spellCheckingResult As SpellCheckingResult In e.Results
        ' A localização do primeiro símbolo na palavra mal escrita
        ' no texto verificado que é considerado mal escrito
        ' pelo corretor ortográfico.
        Dim location As UInteger = spellCheckingResult.Location
        ' O comprimento da palavra mal escrita no texto verificado.
        Dim length As UInteger = spellCheckingResult.Length
    Next
End Sub
Go Top