IdentifiantMot de passe
Mot de passe oublié ?Je m'inscris ! (gratuit)
logo

FAQ DelphiConsultez toutes les FAQ

Nombre d'auteurs : 124, nombre de questions : 929, dernière mise à jour : 31 décembre 2023  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums Delphi et Delphi et bases de données de www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose soient correctes. Les auteurs font le maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous souhaitez y apporter des corrections ou la compléter, contactez un responsable (lien au bas de cette page).

Nous espérons que cette FAQ saura répondre à vos attentes. Nous vous en souhaitons une bonne lecture.

L'équipe Delphi de Developpez.com.

Sommaire →Microsoft Office →Microsoft Word →Gestion des documents (14)
précédent sommaire suivant
 
HautPage
Comment créer un nouveau document ?

Pour créer un nouveau document :

Code delphi : Sélectionner tout 
1
2
3
4
5
6
var DocWord:_document; 
begin 
    WordApplication1.Connect; 
    WordApplication1.Visible:=True; 
    DocWord:=WordApplication1.Documents.Add(EmptyParam,EmptyParam); 
end;
Remarques : La forme principale contient un composant TWordApplication qui est un descendant de TOleServer.
On utilise la propriété ConnectKind pour indiquer comment le composant TOleServer établira la connexion.
Code delphi : Sélectionner tout 
WordApplication1.ConnectKind := ckNewInstance;
ici on spécifie la création d'une nouvelle instance de Word.
Ensuite il reste à connecter le composant TOleServer au serveur COM qu'il représente en utilisant la méthode Connect.

Mis à jour le 18 janvier 2014 bidou
HautPage
Comment créer un nouveau document depuis un modèle ?

Pour créer un nouveau document en utilisant un modèle particulier vous devez préciser le nom du modèle par l'intermédiaire du paramètre Template
Par défaut, le modèle de document Normal.dot est appliqué au nouveau document. Dans ce cas là, le paramètre Template sera égal à EmptyParam.

Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
var DocWord:_document;  
   Template,  
   AsModel: OleVariant;  
begin  
    WordApplication1.Connect;  
    WordApplication1.Visible:=True;  
    Template:='C:\Program Files\Microsoft Office\Modèles\Rapports\Rapport professionnel.dot';  
    AsModel:=False;  
    DocWord:=WordApplication1.Documents.Add(Template,AsModel);  
end;
Remarques :
Si vous souhaitez créer un nouveau modèle de documents vous devez indiquer True dans le second paramètre (ici AsModel) et renseigner le paramètre Template avec le nom du nouveau modèle.

Mis à jour le 18 janvier 2014 bidou
HautPage
Comment ouvrir un document existant ?

Pour ouvrir un document on exécute la méthode Open.
Elle peut être utilisée de 2 manières différentes

Soit EmptyParam remplace tous les noms de variables que l'on ne souhaite pas renseigner. On l'utilisera directement dans l'appel de méthode souhaitée.
Par défaut chaque variable est de type OleVariant, pour d'autre fonction on pourra préciser le type (Range, Selection…).

Certaines déclarations de procédures et fonctions sont différentes entre entre Word97 et Office2000, consulter l'aide en ligne sur la programmation VBA de Microsoft Word.

Code pour Office2000

Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
12
13
procedure TForm1.BtOpenDocClick(Sender: TObject); 
var 
    DocWord:_Document; 
    FileName: OleVariant; 
    Visible: OleVariant; 
  
begin 
    FileName:= 'Document.doc'; // ou .rtf ... 
    Visible:=True;  // Le serveur COM est affiché  
    DocWord:= WordApplication1.Documents.Open(FileName, EmptyParam, EmptyParam, 
                          					  EmptyParam, EmptyParam, EmptyParam, EmptyParam, 
					                          EmptyParam, EmptyParam, EmptyParam, EmptyParam, Visible); 
end;
Soit on déclare une variable pour chaque paramètre déclaré, on pourra ainsi préciser les propriétés du document.
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
var 
    DocWord:_Document; 
  
    FileName: OleVariant;  
    ConfirmConversions: OleVariant; 
    ReadOnly: OleVariant; 
    AddToRecentFiles: OleVariant; 
    PasswordDocument: OleVariant; 
    PasswordTemplate: OleVariant; 
    Revert: OleVariant; 
    WritePasswordDocument: OleVariant; 
    WritePasswordTemplate: OleVariant; 
    Format: OleVariant; 
    Encoding: OleVariant; 
    Visible: OleVariant; 
  
begin 
  
    FileName:= 'Document.doc'; // ou Document.rtf, ... 
    ConfirmConversions:=False; 
    ReadOnly:=False; 
    AddToRecentFiles:=False; 
    PasswordDocument:=EmptyParam; 
    PasswordTemplate:=EmptyParam; 
    Revert:=False; 
    WritePasswordDocument:=EmptyParam; 
    WritePasswordTemplate:=EmptyParam; 
    Format:=EmptyParam; 
    Encoding:=EmptyParam; 
  
    Visible:=True; // Le serveur COM est affiché  
  
    DocWord:=WordApplication1.Documents.Open(FileName, ConfirmConversions, ReadOnly, 
                                            AddToRecentFiles, PasswordDocument, 
                                            PasswordTemplate, Revert, 
                                            WritePasswordDocument, 
                                            WritePasswordTemplate, Format, 
                                            Encoding, Visible); 
end;
Pour Word97 utiliser cet appel
Code delphi : Sélectionner tout 
1
2
3
4
DocWord:=WordApplication1.Documents.OpenOld( 
                      FileName, EmptyParam, EmptyParam, EmptyParam, 
                      EmptyParam, EmptyParam, EmptyParam, EmptyParam, 
                      EmptyParam, EmptyParam);
Le composant TWordApplication est 'propriétaire' de tous les documents.
Il propose la collection nommée Documents qui contient tous les documents de l'instance de Word avec laquelle vous travaillez.

Mis à jour le 18 janvier 2014 bidou
HautPage
Comment générer les statistiques ?

Il suffit de demander les statistiques souhaitées :

Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
NomFichier:='c:\tuto.doc'; 
DocWord:=WordApplication1.Documents.Open(NomFichier,EmptyParam, 
               EmptyParam,EmptyParam,EmptyParam,EmptyParam,EmptyParam, 
               EmptyParam,EmptyParam,EmptyParam,EmptyParam,EmptyParam); 
ShowMessage('Le documents contient '  
      +inttostr(DocWord.ComputeStatistics(wdStatisticPages,EmptyParam)) + ' pages et '  
      +inttostr(DocWord.ComputeStatistics(wdStatisticWords,EmptyParam)) + ' mots');
Vous pouvez obtenir les statistiques pour
  • wdStatisticCharacters : nombre de caractères
  • wdStatisticCharactersWithSpaces : nombre de caractères avec les espaces
  • wdStatisticLines : nombre de lignes
  • wdStatisticPages : nombre de pages
  • wdStatisticParagraphs : nombre de paragraphes (retour chariot)
  • wdStatisticWords : nombre de mots

Note: Nous vous invitons a consulter l'unité Delphi spécifique à votre version d'Office afin d'avoir un liste exhaustive des constantes prisent en compte

Mis à jour le 18 janvier 2014 bidou
HautPage
Comment sauver le document ouvert ?

Pour enregistrer le document ouvert avec son nom par défaut, simplement utiliser la méthode Save :

Code delphi : Sélectionner tout 
DocWord.Save;
Pour enregistrer le document sous un nouveau nom, il faut utiliser la méthode SaveAs :
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
Var NomFichier:OleVariant; 
begin 
  NomFichier:='c:\temp\tuto.doc'; 
  DocWord.SaveAs(NomFichier,EmptyParam,EmptyParam, 
                 EmptyParam,EmptyParam,EmptyParam,EmptyParam, 
                 EmptyParam,EmptyParam,EmptyParam,EmptyParam); 
end;

Mis à jour le 18 janvier 2014 Nono40
HautPage
Comment enregistrer un document ?

Pour accéder à chaque élément de la collection Documents on utilise la méthode Item(index).
Cette méthode renvoie une interface de type _Document, on utilisera une variable de type Variant pour gérer cette interface.
On utilise la méthode Save pour enregistrer le document.

Le paramètre NoPrompt permet d'enregistrer le document sans intervention de l'utilisateur.

Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
procedure TForm1.btSaveDocClick(Sender: TObject); 
var NoPrompt: OleVariant; 
    I : OLEVariant; 
    UnDoc : Variant; 
begin 
 NoPrompt:=True; 
 I:=1; 
 UnDoc:=WordApplication1.Documents.Item(I); 
 UnDoc.Save(NoPrompt); 
end;
À noter que la sélection d'un document peut se faire par un nom de fichier.
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
procedure TForm1.btSaveDocClick(Sender: TObject); 
var NoPrompt: OleVariant; 
    I : OLEVariant; 
    UnDoc : Variant; 
begin 
 NoPrompt:=True; 
 I:='Document2';; 
 UnDoc:=WordApplication1.Documents.Item(I); 
 UnDoc.Save(NoPrompt); 
end;

Mis à jour le 18 janvier 2014 Laurent Dardenne
HautPage
Comment quitter Word sans enregistrer les documents ouverts ?

Pour ne pas enregistrer un document lorsque vous quitter Word, utilisez le paramètre SaveChanges.

Code delphi : Sélectionner tout 
1
2
3
4
5
var  SaveChanges: OleVariant; 
begin 
 SaveChanges := wdDoNotSaveChanges; 
 WordApplication1.Quit(SaveChanges); 
end;

Mis à jour le 18 janvier 2014 Laurent Dardenne
HautPage
Comment fermer tous les documents ouverts ?

On utilise la méthode Close. Le paramètre SaveChanges modifie le comportement de la méthode Close.

Dans l'exemple suivant, la méthode ferme tous les document sans demander de confirmation à l'utilisateur.

Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
12
Var I     : OLEVariant; 
SaveChanges: OleVariant; 
    UnDoc : Variant; 
begin 
  I:=1; 
  SaveChanges:=wdSaveChanges;  
  While WordApplication1.Documents.Count >=1 do 
   begin 
    UnDoc:=WordApplication1.Documents.Item(I); 
    UnDoc.Close(SaveChanges);; 
   end; 
end;

Mis à jour le 18 janvier 2014 Laurent Dardenne
HautPage
Comment fonctionnent les protections dans Word ?

Elles sont de plusieurs sortes.

Mot de passe d'accès

Code delphi : Sélectionner tout 
objDoc.Password:= 'passe';
Ce code doit être passé dans la méthode open pour ouvrir le document par le code :
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
Var NomFichier:OleVariant; 
    MotDePasse:OleVariant; 
begin 
  NomFichier:='c:\temp\tuto.doc'; 
  MotDePasse:='abcde'; 
  DocWord:=WordApplication1.Documents.Open(NomFichier,EmptyParam, 
                EmptyParam,EmptyParam,MotDePasse,EmptyParam, 
                EmptyParam,MotDePasse,EmptyParam,EmptyParam); 
end;
Protection spécifique
Code delphi : Sélectionner tout 
1
2
3
Param1:=False; 
    Param2:='MonPasse'; 
    DocWord.Protect(wdAllowOnlyComments,Param1,Param2);
Dans ce cas, seuls les commentaires sont autorisés. Pour ôter la protection, utiliser le type wdNoProtection ou la méthode UnProtect

Mis à jour le 18 janvier 2014 bidou
HautPage
Comment lire les propriétés d'un document ?

Les propriétés d'un document se trouvent dans 2 collections

  • la collection BuiltInDocumentProperties contient les propriétés prédéfinies d'un document.
  • la collection CustomDocumentProperties contient les propriétés personnalisées d'un document.

Lorsqu'une application conteneur ne définit pas de valeur pour l'une des propriétés de document prédéfinies,la lecture de la propriété Value de cette propriété de document provoque une erreur.
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Var I : OLEVariant; 
    J:Integer; 
    Doc:OleVariant; 
    S: OleVariant; 
begin 
 Doc := WordApplication1.ActiveDocument; 
 I:=Doc.BuiltInDocumentProperties.Count; 
 LBLigneWord.Items.Add(InttoStr(I)+' Propriétés'); 
  
 for J:=1 to I do 
 begin 
  try 
   S:=varEmpty; 
   if not VarIsNull(Doc.BuiltInDocumentProperties[J].Name) 
    then 
     begin 
      S:='la Propriété '+InttoStr(J)+' se nomme ['+Doc.BuiltInDocumentProperties[J].Name; 
      if not VarIsNull(Doc.BuiltInDocumentProperties[J].Value) then 
       if Not VarIsEmpty(Doc.BuiltInDocumentProperties[J].Value) then 
        S:=S+']. Son contenu ='+Doc.BuiltInDocumentProperties[J].Value; 
    end; 
   LBLigneWord.Items.Add(S); 
  except 
   on E:Exception do 
    if (E is EOlEException) or (E is EVariantError) then 
     LBLigneWord.Items.Add(S+'] * Propriété indéfinie *'); 
  end; 
 end; 
end;

Mis à jour le 18 janvier 2014 Laurent Dardenne
HautPage
Comment exécuter un mailing ?

On doit utiliser l'objet MailMerge d'un document pour accéder à la fonction de mailing.

Avant d'exécuter cette méthode, vous devez disposer des deux documents suivants :

  • un fichier .dot contenant le modèle du document type
  • un fichier texte contenant les données à insérer lors de la fusion/Publipostage, ce fichier texte étant la source de données utilisée par Word.

L'itération sur les enregistrements de la source de données n'est pas automatiquement effectué par Word.
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
var 
   DocWord : _Document; 
   NewWord : _Document; 
  
   DotFilename, 
   DocResultat, 
   Pause, 
   SaveChanges, 
   Visible : OleVariant; 
  
   LigneCourante, 
   LigneTotal :Integer; 
  
begin 
 Try 
  
  SaveChanges := wdDoNotSaveChanges; 
  
   // Contient les champs de publipostage 
  DotFilename :='C:\Temp\Mailing.dot'; 
   // Démarre à la premiére ligne 
  LigneCourante:=1; 
   // N'affiche pas le document 
  WordApplication1.Visible := False; 
  
   // On ouvre le Modéle de document concerné par le publipostage 
  DocWord:=WordApplication1.Documents.Open(DotFileName,EmptyParam,EmptyParam, 
                                           EmptyParam,EmptyParam, 
                                           EmptyParam,EmptyParam, 
                                           EmptyParam,EmptyParam, 
                                           EmptyParam,EmptyParam, 
                                           Visible); 
      {Prépare le publipostage} 
  With DocWord Do 
   With MailMerge Do 
   Begin 
      // Définit le type du document principal du publipostage 
     MainDocumentType := wdFormLetters; 
  
      // Associe une source de données au document spécifié, qui devient alors 
      // le document principal, s'il ne l'était pas encore. 
     OpenDataSource(ExtractFilePath(DotFilename)+'Data.txt', 
                    EmptyParam,EmptyParam,EmptyParam,EmptyParam,EmptyParam, 
                    EmptyParam,EmptyParam,EmptyParam,EmptyParam,EmptyParam, 
                    EmptyParam,EmptyParam,EmptyParam); 
  
     Destination := wdSendToNewDocument; // Définit la destination du résultat de la fusion 
  
     MailAsAttachment := False;  // Le résultat n'est pas envoyé par mail 
     MailAddressFieldName := ''; // Adresse Email 
     MailSubject := '';          // Sujet du mail 
  
     SuppressBlankLines := True; // les lignes vides sont supprimées quand les 
                                 // champs d'un document principal 
                                 // de publipostage sont vides. 
  
  {Execute le publipostage} 
  
    {Pause 
      True : Word s'interrompe et affiche une boîte de dialogue de dépannage 
       chaque fois qu'il rencontre une erreur liée à la fusion et au publipostage. 
      False : consigne les erreurs dans un nouveau document. 
    } 
    Pause:=False; 
     // traite toutes les lignes 
    DataSource.ActiveRecord:= wdLastRecord; 
     // Récupére le nombre de ligne à traiter 
    LigneTotal:=DataSource.ActiveRecord; 
     // Se repositionne sur la premiére ligne 
    DataSource.ActiveRecord:= wdFirstRecord; 
  
    While LigneCourante <= LigneTotal do 
     begin 
      DataSource.FirstRecord := LigneCourante; 
      DataSource.LastRecord  := LigneCourante; 
  
      Execute(Pause); 
      {Rend actif le document crée par la fusion} 
      NewWord:=WordApplication1.ActiveDocument; 
  
      DocResultat := ExtractFilePath(DotFilename)+'Resultat'+IntToStr(LigneCourante)+'.doc'; 
  
      NewWord.SaveAs(DocResultat,EmptyParam,EmptyParam,EmptyParam,EmptyParam, 
                     EmptyParam,EmptyParam,EmptyParam,EmptyParam,EmptyParam, 
                     EmptyParam); 
  
      Inc(LigneCourante); 
  
      NewWord.Close(SaveChanges,EmptyParam,EmptyParam); 
     end; // while 
   End; {With MailMerge} 
  {With WordDoc} 
 Finally 
  DocWord.Close(SaveChanges,EmptyParam,EmptyParam); 
 end; 
end;

Mis à jour le 18 janvier 2014 Laurent Dardenne
HautPage
Comment exécuter un mailing en récupérant les informations d'une base de données ?

Le code qui permet d'associer un mailing avec des données d'une SGBD diffère peu de celui de la question Comment exécuter un mailing ? on peut donc réutiliser son code d'exemple.

Le fichier Word .dot doit contenir des champs de fusion portant le même nom que les champs de la table que vous souhaitez utiliser. L'instruction suivante ajoute, au point d'insertion, un champ de fusion/publipostage :

Code delphi : Sélectionner tout 
Doc.MailMerge.Fields.Add(R, 'Company');
Ajoutez cette fonction qui récupére le chemin des bases de données de démonstration de Delphi. Vous devez ajouter dans la clause uses de la partie implémentation l'unité Dbtables.
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function GetAliasPath: string; 
  const 
    DemoAlias = 'DBDEMOS'; 
  var 
    AliasParams: TStrings; 
  begin 
    Result := 'C:\'; 
     // s'assure que la chaîne correspond au nom d'un alias BDE 
    if Session.IsAlias(DemoAlias) then 
    begin 
      AliasParams := TStringList.Create; 
      try 
         // Renvoie les paramètres associés à un alias spécifique du BDE 
        Session.GetAliasParams(DemoAlias, AliasParams); 
        Result := AliasParams.Values['PATH']; 
      finally 
        AliasParams.Free; 
      end; 
    end; 
  end;
Puis ajoutez cette procédure qui prépare et associe une source de données pour le document utilisé lors du mailing.
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
procedure GetDataSource; 
  var 
    AliasPath: string; 
  
    TblName, wFormat, ConfConv,ReadOnly, 
    LinkToSrc,AddToRecent, PWordDoc, PWordTemplate, 
    Revert,WritePWordDoc, WritePWordTemplate,Connection, 
    SQL, SQL1  : OleVariant; 
  
  begin 
     // Récupère le path de la table concernée 
    AliasPath:=GetAliasPath; 
  
        { Ouvre la table customer } 
    TblName := AliasPath + '\' + 'customer.db'; 
    wFormat:=wdOpenFormatAuto; 
    ConfConv := False; 
    ReadOnly := False; 
    LinkToSrc := True; 
    AddToRecent := False; 
    PWordDoc := EmptyParam; 
    PWordTemplate := EmptyParam; 
    Revert:= EmptyParam; 
    WritePWordDoc := EmptyParam; 
    WritePWordTemplate := EmptyParam; 
  
      // Format ODBC, DSN en langue Française. 
    Connection := Format('DSN=Fichiers Paradox;DBQ=%s;DefaultDir=%s;DriverId=538;' 
              +'MaxBufferSize=2048;PageTimeout=5;', [AliasPath, AliasPath]); 
     // Récupére tout les champs 
    SQL := 'SELECT * FROM customer.db'; 
    SQL1 := EmptyParam; 
  
    // Associe une source de données au document spécifié. 
    DocWord.MailMerge.OpenDataSource(''TblName, wFormat, ConfConv, ReadOnly, LinkToSrc, 
                                      AddToRecent, PWordDoc, PWordTemplate, Revert, 
                                      WritePWordDoc, WritePWordTemplate, 
                                      Connection, SQL, SQL1) 
  end;
Dans la partie prépare la fusion du code récupéré, remplacez le code suivant :
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
// Définit le type du document principal du publipostage 
     MainDocumentType := wdFormLetters; 
  
      // Associe une source de données au document spécifié, qui devient alors 
      // le document principal, s'il ne l'était pas encore. 
     OpenDataSource(ExtractFilePath(DotFilename)+'Data.txt', 
                    EmptyParam,EmptyParam,EmptyParam,EmptyParam,EmptyParam, 
                    EmptyParam,EmptyParam,EmptyParam,EmptyParam,EmptyParam, 
                    EmptyParam,EmptyParam,EmptyParam); 
  
     Destination := wdSendToNewDocument; // Définit la destination du résultat de la fusion
par celui-ci
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
// Définit le type du document principal du publipostage 
     MainDocumentType := wdFormLetters; 
  
     Destination := wdSendToNewDocument; // Définit la destination du résultat de la fusion 
  
  // Associe une source de données correspondant à une table d'une base de donnée.  
     GetDataSource;

Mis à jour le 18 janvier 2014 Laurent Dardenne
HautPage
Comment imprimer un document ?

Utiliser la méthode PrintOut.
Le paramètre Range permet de spécifier l'étendue de la plage de pages concernées par l'impression.
Le paramètre PageType permet de spécifier le type des pages à imprimer.
Le paramètre Background permet d'attendre ou non la fin de la génération de l'impression.
Renseigner la paramètre Background à True permet d'imprimer en tâche de fond, la méthode PrintOut se terminant sans attendre la fin de la génération de l'impression.

Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var Range: OleVariant; 
    PageType: OleVariant;   
    Background: OleVariant;   
begin 
 Range:=wdPrintAllDocument; // page Courante  = wdPrintCurrentPage, ... 
 PageType:=wdPrintAllPages; // pages impaires = wdPrintOddPagesOnly, ... 
 Background:=False;   
  
 WordApplication1.ActiveDocument.PrintOut(BackGround,EmptyParam, 
                                          Range, 
                                          EmptyParam,EmptyParam,EmptyParam, 
                                          EmptyParam,EmptyParam,EmptyParam, 
                                          PageType, 
                                          EmptyParam,EmptyParam,EmptyParam, 
                                          EmptyParam,EmptyParam,EmptyParam, 
                                          EmptyParam,EmptyParam); 
end;
Pour activer le mode Aperçu avant impression, utiliser la méthode PrintPreview.
Code delphi : Sélectionner tout 
1
2
3
begin 
 WordApplication1.ActiveDocument.PrintPreview; 
end;

Mis à jour le 18 janvier 2014 Laurent Dardenne
HautPage
Comment exécuter une Macro Word ?

Pour exécuter une macro Word dans Delphi il faut appeler la méthode Run() de l'objet WordApplication.
Le premier paramètre est le nom de la macro, les paramètres suivants sont les valeur à passer à la macro.

Par exemple pour exécuter la macro Conversion contenue dans le fichier MaMacro.doc :

Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Var  
  MacroWord : TWordApplication;  
  MacroName : OleVariant;  
  MacroDoc1 : _Document;  
  Param1    : OleVariant;  
  Param2    : OleVariant;  
...  
  // Connexion à Word  
  MacroWord := TWordApplication.Create(Application);  
  MacroWord.Connect;  
  
  // Ouverture du fichier contenant la macro  
  MacroName:= 'MaMacro.doc';  
  MacroDoc1:= MacroWord.Documents.Open(MacroName  
        ,EmptyParam,EmptyParam,MacroFalse,EmptyParam,EmptyParam  
        ,EmptyParam,EmptyParam,EmptyParam,EmptyParam,EmptyParam  
        ,EmptyParam,EmptyParam,EmptyParam,EmptyParam,EmptyParam);  
  
  // Exécution de la macro  
  Param1 := 'Valeur 1';  
  Param2 := 'Valeur 2';  
  MacroWord.Run('Conversion',Param1,Param2);
Si le fichier contenant la macro n'est pas le document actif dans Word, vous obtiendrez l'erreur 'Membre Introuvable', dans ce cas il faut activer le document contenant la macro avant de l'appeler :
Code delphi : Sélectionner tout 
1
2
MacroDoc1.Activate;  
  MacroWord.Run('Conversion',FileName,ZoneCode);

Mis à jour le 18 janvier 2014 Nono40

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2024 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.