Utilisation du correcteur orthographique de Word

Date de publication : 14/07/2005 , Date de mise a jour : 31/07/2005

Par Nono40 (nono40.developpez.com)
 

Utilisation du correcteur orthographique de Microsoft Word dans une application Delphi.
Les exemples présentés ici sont testés avec Delphi 2005 et Word 2003.

I. Introduction

II. Avant de commencer

IUnknown(TVarData(Params[0]).VPointer) as Range {const Range},

IUnknown(TVarData(Params[0]).VPointer) as Word_TLB.Range {const Range},

III. Première méthode : WordApplication.CheckSpelling

III-A. Début du projet

type
  TFenCorrecteur = class(TForm)
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
    Procedure Verifie(Texte:TRichEdit);
  end;

III-B. Objets word utilisés

procedure TFenCorrecteur.Verifie(Texte: TRichEdit);
Var Word:TWordApplication;
    Doc :_Document;
    SaveChanges:OleVariant;
begin
  Word := TWordApplication.Create(Self);
  Try
    // Ouverture de word et création d'un document vide
    Word.ConnectKind := ckNewInstance;
    Word.Connect;
    Doc:=Word.Documents.Add(EmptyParam, EmptyParam, EmptyParam, EmptyParam);

  Finally
    SaveChanges := wdDoNotSaveChanges;
    Word.Quit(SaveChanges);
    Word.Free;
  End;
end;

III-C. Principe de gestion de la correction

Début : position actuelle
Fin : fin du document
Si début correction en milieu de mot, aller en fin de mot
Tant que pas fin de texte
| Chercher le prochain mot
| Tester/Corriger le mot
| Tester fin de document
| | Si (début<>début document)Et(fin document atteinte )
| | | Demander si recommencer depuis début, si oui :
| | | | Fin : début
| | | | Début : début document
Fin correction

procedure TFenCorrecteur.Verifie(Texte: TRichEdit);
Var Word:TWordApplication;
    Doc :_Document;
    SaveChanges:OleVariant;
begin
  Word := TWordApplication.Create(Self);
  Try
    // Ouverture de word et création d'un document vide
    Word.Connect;
    Doc:=Word.Documents.Add(EmptyParam, EmptyParam, EmptyParam, EmptyParam);

    // Il faut balayer le document pour en séparer les mots.
    Chaine := Texte.Text;
    DebutCorrection := Texte.SelStart;
    i := DebutCorrection;
    FinCorrection := Length(Chaine);

    // Si on commence en milieu de mot on va en fin de mot de suite.
    While (i<FinCorrection)And(Chaine[i]In Lettres) Do Inc(i);

    // Recherche et test de tous les mots du document
    While i<FinCorrection Do
    Begin
      // Une lettre signale un début de mot
      If Chaine[i]In Lettres Then
      Begin
        Debut := i;
        Mot := Chaine[i];
        Inc(i);
        While (i<=Length(Chaine))And(Chaine[i]In LettresSigne) Do
        Begin
          Mot := Mot + Chaine[i];
          Inc(i);
        End;
        Fin := i;
        // Ici le mot est isolé, commence alors la vérification
        //.....
      End
      Else Inc(i);
      // Test de fin de document quand on est pas parti du début
      If (i>=FinCorrection)And(DebutCorrection>1) Then
      Begin
        If MessageDLG('La correction à atteint la fin du document, voulez vous-corriger le début ?'
              ,mtConfirmation,[mbYes,mbNo],0)=mrYes Then
        Begin
          FinCorrection := DebutCorrection-1;
          DebutCorrection:=1;
          i:=DebutCorrection;
        End;
      End;
    End;
    ShowMessage('Vérification terminée.');
  Finally
    SaveChanges := wdDoNotSaveChanges;
    Word.Quit(SaveChanges);
    Word.Free;
  End;
end;

Dans le cas où tous les mots de doivent pas être corrigés, il faut compléter cette procédure et ajouter des conditions sur la correction du mot.

Const
   corAbandon        = 0;
   corRemplacer      = 1;
   corRemplacerTout  = 2;
   corIgnorer        = 3;
   corIgnorerTout    = 4;
   corAjouterDico    = 5;
   
procedure TFenCorrecteur.btnAbandonClick(Sender: TObject);
begin
  Tag := corAbandon;
end;

procedure TFenCorrecteur.btnRemplacerClick(Sender: TObject);
begin
  Tag := corRemplacer;
end;

procedure TFenCorrecteur.btnToutRemplacerClick(Sender: TObject);
begin
  Tag := corRemplacerTout;
end;

procedure TFenCorrecteur.btnIgnorerClick(Sender: TObject);
begin
  Tag := corIgnorer;
end;

procedure TFenCorrecteur.btnToutIgnorerClick(Sender: TObject);
begin
  Tag := corIgnorerTout;
end;

procedure TFenCorrecteur.btnAjoutDicoClick(Sender: TObject);
begin
  Tag := corAjouterDico;
end;

III-D. Tester et corriger chaque mot

SpellingSuggestions.Item(N) est indexé à partir de 1 et non de 0, la boucle doit donc parcourir de 1 à SpellingSuggestions.Count !

// On prépare la fenêtre de demande de correction
eInconnu.Text := Mot;
eListe.Items.Clear;
Sugg := Word.GetSpellingSuggestions(Mot);
For j:=1 To Sugg.Count Do
  eListe.Items.Add(Sugg.Item(j).Name);
If Sugg.Count>=1 Then
Begin
  eRemplacer.Text := Sugg.Item(1).Name;
  eListe.Enabled := True;
End Else
Begin
  eRemplacer.Text := Mot;
  eListe.Items.Add('Pas de suggestion');
  eListe.Enabled := True;
End;

// On se place dans RichEdit au bon endroit
Texte.SelStart := Debut-1;
Texte.SelLength := Fin-Debut;

// affichage de la fenêtre et traitement
Tag := corAbandon;
ShowModal;
Case Tag Of
  corAbandon : Exit;    // Annuler/Abandon sort de la procédure
  corIgnorer :;         // ignore ne fait rien et passe au mot suivant
  corRemplacer:Begin    // On change il faut alors modifier le texte
    // Remplacement dans le R
    Texte.SelText := eRemplacer.Text;
    // Remplacement dans la chaîne (pour que les positions correspondent)
    Delete(Chaine,Debut,Fin-Debut);
    Insert(eRemplacer.Text,Chaine,Debut);
    i:=Debut+Length(eRemplacer.Text);
  End;
End;

III-E. Ajouter 'remplacer tout' et 'ignorer tout'

// Ici le mot est isolé, commence alors la vérification
If Not Word.CheckSpelling(Mot) Then
Begin
  // On teste déjà s'il ne fait pas partie des mots à ignorer cette fois-ci
  If ListeIgnore.IndexOf(Mot)<0 Then
  Begin
    // On teste ensuite si le mot n'est pas dans la liste des "tout remplacer"
    If ListeRemplace.IndexOfName(Mot)<0 Then
    Begin
      // ...
      // Traitement normal
      // ...
    End Else
    Begin // Le mot fait partie de "tout remplacer", on le fait donc directement
      // On se place dans le RichEdit au bon endroit
      Texte.SelStart := Debut-1;
      Texte.SelLength := Fin-Debut;
      // Remplacement dans le RichEdit
      Texte.SelText := ListeRemplace.Values[Mot];
      // Remplacement dans la chaîne (pour que les positions correspondent)
      Delete(Chaine,Debut,Fin-Debut);
      Insert(ListeRemplace.Values[Mot],Chaine,Debut);
      i:=Debut+Length(ListeRemplace.Values[Mot]);
    End;
  End;
End;

Case Tag Of
  corAbandon : Exit;    // Annuler/Abandon sort de la procédure
  corIgnorer :;         // ignorer ne fait rien et passe au mot suivant
  corIgnorerTout :Begin // ignorer tout ajoute le mot dans la liste des mots ignorés
    ListeIgnore.Add(eInconnu.Text);
  End;
  corRemplacerTout,
  corRemplacer:Begin    // On change il faut alors modifier le texte
    // Remplacement dans le RichEdit
    Texte.SelText := eRemplacer.Text;
    // Remplacement dans la chaîne (pour que les positions correspondent)
    Delete(Chaine,Debut,Fin-Debut);
    Insert(eRemplacer.Text,Chaine,Debut);
    i:=Debut+Length(eRemplacer.Text);
    // Dans le cas de tout remplacer, on garde la trace du changement sous la main
    If Tag=corRemplacerTout Then
      ListeRemplace.Add(Mot+'='+eRemplacer.Text);
  End;
End;

III-F. Changer la langue de vérification

• Aller dans Menu Démarrer->Programmes->Microsoft Office->Outils Microsoft Offife->Paramètres linguistiques
• Dans le bas choisir la langue par défaut des applications Office
• Valider
• Il faut ensuite choisir "Confirmer et perdre les personnalisations"

Cette méthode va changer la langue par défaut de toutes les applications, de plus si Word est déjà lancé elle ne sera prise qu'au prochain démarrage. Nous allons donc utiliser une autre méthode.

If Not Word.CheckSpelling(Mot) Then
//...
Sugg := Word.GetSpellingSuggestions(Mot);

Word.Selection.Text := Mot;
If Word.Selection.Range.SpellingErrors.Count>0 Then
//...
Sugg := Word.Selection.Range.GetSpellingSuggestions(EmptyParam,EmptyParam,EmptyParam
                             ,EmptyParam,EmptyParam,EmptyParam,EmptyParam,EmptyParam
                             ,EmptyParam,EmptyParam,EmptyParam,EmptyParam,EmptyParam);

Word.Selection.LanguageID := wdEnglishUS;
// ou
Word.Selection.LanguageID := wdFrench;

Il faut bien sûr que le dictionnaire correspondant soit installé dans Word pour que la vérification fonctionne.

IV. Seconde méthode : utiliser la boîte de dialogue de Word

III-A. Début du projet

unit UCorrecteur;

interface

Uses ComCtrls;

Procedure Verifie(Texte: TRichEdit);

implementation

Uses Classes,Forms,Variants,SysUtils,Dialogs,Word_TLB,OleServer;

procedure Verifie(Texte: TRichEdit);
begin
  //...
end;

IV-B. Objets word utilisés

procedure Verifie(Texte: TRichEdit);
Var Word:TWordApplication;
    Doc :_Document;
    SaveChanges:OleVariant;
begin
  Word := TWordApplication.Create(Application);
  Try
    // Ouverture de word et création d'un document vide
    Word.ConnectKind := ckNewInstance;
    Word.Connect;
    Doc:=Word.Documents.Add(EmptyParam, EmptyParam, EmptyParam, EmptyParam);

  Finally
    SaveChanges := wdDoNotSaveChanges;
    Word.Quit(SaveChanges);
    Word.Free;
  End;
end;

IV-C. Corriger le texte

procedure Verifie(Texte: TRichEdit);
Var Word:TWordApplication;
    Doc :_Document;
    SaveChanges:OleVariant;
begin
  Word := TWordApplication.Create(Application);
  Try
    // Ouverture de word et création d'un document vide
    Word.ConnectKind := ckNewInstance;
    Word.Connect;
    Doc:=Word.Documents.Add(EmptyParam, EmptyParam, EmptyParam, EmptyParam);

    // copie du texte dans Word
    Doc.Content.Text := Texte.Text;

    // Appel de la fenêtre de correction de Word, le texte modifié est contenu dans
    // l'objet _Document, on n'a pas de contrôle sur ce qui se passe.
    // On récupère le texte modifié par Word sauf si la correction est annulée
    If Word.Dialogs.Item(wdDialogToolsSpellingAndGrammar).Show(EmptyParam)<>0
      Then Texte.Text := Doc.Content.Text;

  Finally
    SaveChanges := wdDoNotSaveChanges;
    Word.Quit(SaveChanges);
    Word.Free;
  End;
  ShowMessage('Vérification terminée.');
end;

IV-D. Changer la langue de vérification

// Sélection de la langue de correction
Doc.Content.LanguageID := wdEnglishUS;
// Ou
Doc.Content.LanguageID := wdFrench;

V. Gestion des dictionnaires

V-A. Ajouter un dictionnaire personnalisé

// Test d'existance du dico personnalisé
// Chargement/création suivant le cas
NomDico := ExtractFilePath(ParamStr(0))+MonDico;
If FileExists(NomDico)
  Then ListeDico.LoadFromFile(NomDico)
  Else ListeDico.SaveToFile(NomDico);

// Ajout du dico personnalisé
Dicos := Word.CustomDictionaries;
Trouve:=False;
For i:= 1 To Dicos.Count Do
Begin
  Index:= i;
  If UpperCase(Dicos.Item(Index).Name)=UpperCase(MonDico) Then Trouve:=True;
End;
If Not Trouve Then
  Dicos.Add(NomDico);

// affichage de la fenêtre et traitement
Tag := corAbandon;
ShowModal;
Case Tag Of
  //...
  //...
  corAjouterDico:Begin
    // On met à jour le fichier .dic
    ListeDico.Add(eInconnu.Text);
    ListeDico.SaveToFile(NomDico);
  End;
End;

procedure TFenCorrecteur.btnVoirDicoClick(Sender: TObject);
begin
  ShellExecute(0,'OPEN',PChar(ExtractFilePath(ParamStr(0))+MonDico)
                 ,Nil,Nil,SW_SHOWNORMAL);
end;

V-B. Associer un dictionnaire perso à une langue

// On utilise le nom de fichier comme index de recherche
Index := ExtractFilePath(ParamStr(0))+MonDico;
Dico := Word.CustomDictionaries.Item(Index);
// Le dictionnaire ne sera utilisé que pour les corrections FR
Dico.LanguageSpecific := True;
Dico.LanguageID := wdFrench;

V-C. Connaître la liste des dictionnaires disponibles

procedure TFenLangues.FormShow(Sender: TObject);
Var Word:TWordApplication;
    Langs:Languages;
    SaveChanges:OleVariant;
    IEnum   :IEnumVariant;
    Nombre : Cardinal;
    Element : OleVariant;
    langue : language;
    IDisp : IDispatch;
begin
  Word := TWordApplication.Create(Self);
  Try
    Langs:=Word.Languages;
    IEnum:=Langs._NewEnum as IEnumVariant;
    While IEnum.Next(1,Element,Nombre)=S_OK Do
    Begin
      // Indispensable ici de passer par un IDisp intermédiaire...
      IDisp := Element;
      Langue := IDisp As Language;
      // MAJ de la liste
      With Liste.Items.Add Do
      Begin
        Caption := IntToStr(Langue.ID);
        SubItems.Add(Langue.Name);
        SubItems.Add(Langue.NameLocal);
        If Langue.ActiveSpellingDictionary=Nil
          Then SubItems.Add('Non')
          Else SubItems.Add('Oui');
        If Langue.ActiveGrammarDictionary=Nil
          Then SubItems.Add('Non')
          Else SubItems.Add('Oui');
      End;
    End;
  Finally
    SaveChanges := wdDoNotSaveChanges;
    Word.Quit(SaveChanges);
    Word.Free;
  End;
end;

VI. Téléchargement et liens

 Utiliser Word dans Delphi
MSDN :  CheckSpelling Method
MSDN :  Displaying Built-in Word Dialog Boxes
 More Automation In Delphi

Voir également mes autres articles :

Utiliser Delphi 2005 comme éditeur HTML

Utilisation du correcteur orthographique de Word dans Delphi.

Utiliser l'assembleur en ligne avec Delphi

Utilisation de la propriété TBitmap.ScanLine

Utilisation de TComPort sous Delphi 2005 ( Win 32 )

Installation des composants SynEdit sous Delphi 2005 ( Win 32 )

Réalisation d'un écran de veille avec Delphi

Articles sur Delphi pour .NET

Conversion des pointeurs d'enregistrement sous Delphi .NET

Utilisation des fichiers typés sous Delphi .NET

Utilisation de la classe NotifyIcon dans Delphi .NET

Création d'un contrôle Winform avec Delphi .NET

Programmation réseau avec Delphi pour .NET

Tests et outils

Outil : Test de QuickReport 4 Professionnel

Consultez aussi les sources Delphi :

Les sources de Nono40