News information : Borland C ++ MS Word Automation

présentation

Au départ, j'ai écrit un analyseur C ++ qui a été utilisé pour analyser les documents MS Word donnés et les placer sous la forme d'une structure qui était la plus utile pour le traitement des données. Après avoir écrit l'analyseur, j'ai commencé à travailler avec .NET et C # pour recréer l'analyseur. Dans le processus, j'ai également écrit mon premier article sur Code Project, Automatisation de MS Word à l'aide de Visual Studio .NET. Certaines personnes ont voulu voir la version C ++ de l'application, il m'a donc finalement fallu du temps pour faire quelque chose ensemble. J'ai écrit cet article afin de le rendre plus facile pour quelqu'un qui cherche une réponse rapide. J'espère que les gens pourront profiter des informations fournies et les aider à démarrer rapidement.

fond

Aucun fond spécial n'est nécessaire. Avoir juste de l'expérience avec C ++.

Utiliser le code

Je pense que la meilleure façon de présenter le code serait de vous donner d'abord les parties critiques dont vous avez besoin pour obtenir une instance MS Word, puis de donner les instantanés du code. qui remplissent des fonctions spécifiques. Je pense que cette méthode vous aidera à démarrer plus rapidement le développement de votre logiciel.

Le bloc suivant est la partie titre du fichier CPP.

Remarque: Les fichiers les plus importants incluent et. Ils sont utilisés pour COM et OLE.

// Vahe Karamian – 20/04/2004 – Pour le projet Code
// ———————————————— —————————
#include
#pragma hdrstop

// Nous en avons besoin pour l'objet OLE
#include
#include
# contient "Unit1.h"
#include
// ———————————————— —————————

#pragma package (smart_init)
source #pragma "* .dfm"
TForm1 * Form1;
Le bloc suivant crée l'objet COM MS Word. Il s'agit de l'objet qui sera utilisé pour accéder aux fonctions de l'application MS Word. Pour voir quelles fonctionnalités sont disponibles, vous pouvez le faire dans MS Word. Reportez-vous au premier article, Automatisation de MS Word à l'aide de Visual Studio. NET.

Comme précédemment, vous pouvez exécuter une application Windows Forms ou une application en ligne de commande, le processus est le même. Le code ci-dessous est basé sur une application Windows Forms dotée d'un bouton pour démarrer le processus. Lorsque l'utilisateur clique sur le bouton, l'événement Button1Click (TObject * Sender) sera invoqué et le code exécuté.

Remarque: Pour mieux comprendre le code, ignorez tout dans le code, sauf les parties qui sont mises en surbrillance.

TForm1 * Form1;
// ———————————————— —————————
__fastcall TForm1 :: TForm1 (Composant * Propriétaire)

: TForm (propriétaire)
{
}
// ———————————————— —————————

void __fastcall TForm1 :: Button1Klick (TObject * Sender)
{

.

.

.

// utilisé pour le nom de fichier

Dossier OleVariantName;

fileName = openDialog-> FileName;

Variant my_word;

Variant my_docs;

// crée le mot objet

my_word = Variant :: CreateObject ("word.application");

// rendre le mot visible, pour le rendre invisiblement faux

my_word.OlePropertySet ("Visible", (True Variant));

// récupère l'objet document

my_docs = my_word.OlePropertyGet ("documents");

Variable wordActiveDocument = my_docs.OleFunction ("open", filename);

.

.

.
Donc, une brève explication, nous définissons un type de données OleVariant appelé FileName, assignons un chemin de fichier à notre variable File Name Dans le code ci-dessus, cela se fait à l'aide d'un objet OpenDialog. Bien sûr, vous pouvez simplement définir un chemin complet pour les tests si vous le souhaitez, c'est-à-dire c: test.doc.

Ensuite, nous définissons deux types de données Variant appelés my_word et my_docs. my_word sera utilisé pour créer un mot. application objet et my_docs sera utilisé pour créer un objet document.

Ensuite, nous définissons un autre type de données Variant appelé myActiveDocument. En utilisant cet objet référencé, nous pouvons maintenant faire ce que nous voulons! Dans ce cas, nous ouvrirons le document MS Word donné.

Notez que la plupart des variables sont de type Variant.

À ce stade, nous avons un document Word que nous pouvons commencer à exécuter des fonctions. Au début, cela peut prendre un certain temps avant de voir comment cela fonctionne, mais une fois que vous obtenez le volume, tout dans le champ MS Word est possible.

Jetons un coup d'œil au code suivant, il traitera des tableaux dans un document MS Word.

.

.

Variable wordTables = wordActiveDocument.OlePropertyGet ("Tables");

long table_count = wordTables.OlePropertyGet ("count");

.

.
Comme je l'ai mentionné précédemment, tous vos types de données seront des variantes. Nous déclarons donc un type de données Variant appelé wordTables pour représenter l'objet Tables dans notre objet Document.

Variable wordTables = wordActiveDocument.OlePropertyGet ("Tables");
La ligne ci-dessus renverra tous les objets Table qui se trouvent dans notre objet Document actif. Puisque les tableaux sont une propriété d'un objet Document, nous devons utiliser OlePropertyGet ("Tables"); pour obtenir la valeur.

long table_count = wordTables.OlePropertyGet ("count");
La ligne ci-dessus renverra le nombre de tables dans la table d'objets. Cela se fait en appelant OlePropertyGet ("count"); nous rendre la valeur.

Vous vous demandez peut-être d'où puis-je obtenir ces informations? La réponse à cette question se trouve dans le premier article: Automatisation de MS Word à l'aide de Visual Studio. NET.

Le bloc de code suivant vous montrera comment extraire le contenu de l'objet Tables.

.
.
.
int t, r, c;

essayer
{

pour (t = 1; tFiles-> Strings (i);
vk_converted_filename = openDialog-> Files-> Strings (i) + "_c.doc";

// Ouvrez le fichier Word donné
vk_this_doc = vk_word_doc.OleFunction ("Open", vk_filename);

statusBar-> Panels-> Articles (2) -> Text = "READING";

// ———————————————— ——————-
// Vahe Karamian – 10-10-2003
// Cette partie du code convertira le mot document en
// texte non formaté et nettoyage en profondeur
statusBar-> Panels-> Articles (0) -> Text = "Convert to Text …";
vk_timerTimer (expéditeur);

// Créer un nouveau document
Vk_converted_document variant = vk_word_doc.OleFunction ("Add");

// Sélectionnez le texte du document d'origine
Option vk_this_doc_select = vk_this_doc.OleFunction ("Select");
Option vk_this_doc_selection = vk_word_app.OlePropertyGet ("Choice");

// Copie le texte sélectionné
vk_this_doc_selection.OleFunction ("Copy");

// Insère le texte sélectionné dans le nouveau document
Option vk_converted_document_select =

vk_converted_document.OleFunction ("Select");
Option vk_converted_document_selection =

vk_word_app.OlePropertyGet ("Choice");
vk_converted_document_selection.OleFunction ("PasteSpecial",

0, faux, 0, faux, 2);

// Re-sélectionnez le texte dans le nouveau document
vk_converted_document_select =

vk_converted_document.OleFunction ("Select");
vk_converted_document_selection =

vk_word_app.OlePropertyGet ("Choice");

// Ferme le document d'origine
vk_this_doc.OleProcedure ("Fermer");

// Faisons le ménage ici …
Le mot variantSelectionFind =

vk_converted_document_selection.OlePropertyGet ("Find");

statusBar-> Panels-> Articles (0) -> Text = "Rechercher et remplacer …";
vk_timerTimer (expéditeur);

wordSelectionFind.OleFunction ("Execute", "^ l",

faux, faux, faux, faux, faux, vrai, 1, faux,

"", 2, faux, faux, faux, faux);
wordSelectionFind.OleFunction ("Execute", "^ p", false,

faux, faux, faux, faux, faux, vrai, 1, faux

"", 2, faux, faux, faux, faux);

// Enregistrez le nouveau document
vk_converted_document.OleFunction ("SaveAs", vk_converted_filename);

// Ferme le nouveau document
vk_converted_document.OleProcedure ("Close");
// ———————————————— ——————-
Donc, ce que nous faisons dans le code ci-dessus, nous ouvrons un document existant avec vk_this_doc = vk_word_doc.OleFunction ("Open", vk_filename); Ensuite, nous ajoutons un nouveau document avec Variante vk_converted_document = vk_word_doc.OleFunction ("Add"); Ensuite, nous voulons sélectionner le contenu du document existant et le coller dans notre nouveau document. Cette partie est faite par Variante vk_this_doc_select = vk_this_doc.OleFunction ("Select"); pour obtenir un objet sélectionné et une variante vk_this_doc_selection = vk_word_app.OlePropertyGet ("Selection"); pour obtenir une référence au choix actuel. Ensuite, nous devons copier la sélection à l'aide de vk_this_doc_selection.OleFunction ("Copy"); Ensuite, nous effectuons la même tâche pour le nouveau document avec Variante vk_converted_document_select = vk_converted_document.OleFunction ("Select"); et Variante vk_converted_document_selection = vk_word_app.OlePropertyGet ("Choice");. Pour le moment, nous avons un objet de sélection pour le document existant et le nouveau document. Maintenant, nous allons les utiliser tous les deux pour créer notre propre pâte en utilisant vk_converted_document_selection.OleFunction ("PasteSpecial", 0, false, 0, false, 2); Maintenant, nous avons notre contenu original collé dans un format spécial dans le document nouvellement créé. Nous devons faire un nouvel appel au nouveau document avant de faire notre recherche et remplacement. Pour ce faire, nous utilisons simplement les mêmes appels vk_converted_document_select = vk_converted_document.OleFunction ("Select"); et vk_converted_document_selection = vk_word_app.OlePropertyGet ("Choice"); Ensuite, nous créons un objet Find avec le mot VariantSelectionFind = vk_converted_document_selection.OlePropertyGet ("Find"); et enfin, nous pouvons utiliser notre objet find pour effectuer notre recherche et remplacer par le mot SelectionFind.OleFunction ("Execute", "^ l", false, false, false, false, false, false, true, 1 , faux, "", 2, faux, faux, faux, faux);

Cette & # 39; Tout y est!

Points d'intérêt

La mise en place d'une structure dans un document Word est une tâche difficile, étant donné que de nombreuses personnes ont différentes manières d'autoriser des documents. Cependant, cela aiderait les organisations à commencer à modéliser leurs documents. Cela leur permettra d'appliquer le schéma XML à leurs documents et d'en extraire le contenu beaucoup plus facilement. Il s'agit d'une tâche difficile pour la plupart des entreprises; Habituellement, ils manquent d'expertise ou de ressources. Et ces projets sont de grande envergure car ils affecteront plus d'un domaine d'activité fonctionnel. Mais à long terme, cela sera bénéfique pour l'organisation dans son ensemble. Le fait que vos documents reposent sur des données structurées plutôt que sur le formatage et la perte de documents a beaucoup de valeur ajoutée pour votre entreprise.