OleAutomation

Documentation de OLE Automation
(c) Divalo
Documentation de Ole Automation avec DhAutomation.dll

La DLL DhAutomation permet d'exécuter, dans un programme DIVA, des fonctions proposées par un objet Ole Automation. Elle utilise les fonctions Windows de Ole Automation pour dialoguer avec un serveur Ole tel que Word ou Excel.

I. Visite guidée du langage de commandes de DhAutomation.dll et de Ole Automation

1. Le programme automa.dhop
Le programme automa.dhop permet de saisir des ordres Ole Automation directement au clavier. Les ordres tapés sont automatiquement sauvegardés dans le fichier workTTT, où TTT est le numéro de la tâche en cours qu'il faut créer.
automa.dhop permet ainsi d'exécuter un fichier de commandes. Si Excel est installé sur votre machine, vous pouvez lancer le fichier de démonstration TESTAUTO. Après exécution, le programme revient à la saisie de la première commande. Il affiche le résultat de la commande s'il y en a un, ou une erreur si le serveur n'a pas pu exécuter cette commande.
Pour sortir du programme, tapez sur la touche F9.

2. Exemple d'utilisation du programme automa.dhop
Nous allons maintenant saisir un exemple de commandes pour Excel, le principe restant identique pour les autres serveurs Ole Automation. Lancez le programme automa.dhop et tapez Return à la question "Fichier de commandes".
Les serveurs d'objets Ole Automation proposent parfois leur langage de commandes en plusieurs langues. Si c'est le cas, il faut commencer par envoyer la commande lang afin d'indiquer la langue à utiliser. Par défaut, DhAutomation prend la langue de Windows.
La commande est : lang anglais ou lang francais.

Pour Excel, nous allons travailler avec la langue par défaut et écrire une suite de commandes permettant de modifier et de lire une feuille de calculs en cours d'édition.
Attention : avec Excel 2002 ou 2007, il peut y avoir une erreur lors de l'appel à certaines commandes comme par exemple WorkBooks.Add ou WorkBooks.Open .
Utilisez donc la commande lang que si cette commande est obligatoire pour votre code .
Il existe tout d'abord deux fonctions pour se connecter à un objet Ole Automation : CreateObject et GetObject :

CreateObject ("nom de l'objet") crée un nouvel objet.

Exemple :variable = CreateObject ("Excel.Application")
Lance une nouvelle instance du programme Excel et renvoie un lien vers ce programme.

GetObject ("fichier" , "nom de l'objet") charge un objet déjà existant sur disque ou en mémoire. Cette commande possède trois syntaxes :

Syntaxe 1 :variable = GetObject ("fichier")
Permet de charger un fichier ainsi que l'objet qui gère ce type de fichier (par exemple, une feuille de calcul Excel et le programme Excel lui-même).
Pour charger l'objet, Windows se base sur l'extension du nom du fichier passé en paramètre. Si le fichier est déjà chargé en mémoire, Windows renvoie simplement un lien vers celui-ci.
Exemple :variable = GetObject ("c:\divalto\sys\test.xls")
Cas 1 :Excel n'est pas lancé.
Windows lance Excel et lui demande de charger le fichier
c:\divalto\sys\test.xls.
Cas 2 :Excel est déjà lancé mais le fichier c:\divalto\sys\test.xls n'est pas chargé.
Windows utilise le programme Excel courant et lui demande de
charger le fichier c:\divalto\sys\test.xls.
Cas 3 :Excel est lancé et a ouvert le fichier c:\divalto\sys\test.xls.
Windows utilise le programme Excel courant et renvoie simplement un
lien vers le fichier déjà ouvert par Excel.

Syntaxe 2 :variable = GetObject ( , "nom de l'objet")
Permet de charger un objet déjà présent en mémoire.
Exemple :variable = GetObject ( , "Excel.Application")
Cas 1 : Excel n'est pas lancé.
Une erreur est détectée.
Cas 2 : Excel est déjà lancé.
Windows utilise le programme Excel courant et renvoie un lien sur ce
programme.

Syntaxe 3 :variable = GetObject ("fichier" , "nom de l'objet")
Permet de charger un fichier en spécifiant le nom de l'objet à utiliser.
Remarque : Avec la syntaxe 1, une ambiguïté peut exister si deux logiciels utilisent la même extension. Par exemple, Wordpad et Word gèrent tous deux des fichiers d'extension .doc. La syntaxe 3 permet de lever cette ambiguïté : il vaut donc mieux utiliser la syntaxe 3 plutôt que la 1 si vous connaissez le nom de l'objet à utiliser.
Exemples :variable = GetObject ("c:\divalto\sys\test.xls" , "Excel.Application")
sortira toujours en erreur car les fichiers .xls ne sont pas chargés par
Excel.Application mais par Excel.Sheet !
variable = GetObject ("c:\divalto\sys\test.xls" , "Excel.Sheet")
Cas 1 : Excel n'est pas lancé.
Windows lance Excel et lui demande de charger le fichier
c:\divalto\sys\test.xls.
Cas 2 : Excel est déjà lancé mais le fichier c:\divalto\sys\test.xls n'est pas chargé.
Windows utilise le programme Excel courant et lui demande de charger
le fichier c:\divalto\sys\test.xls.
Cas 3 : Excel est lancé et a ouvert le fichier c:\divalto\sys\test.xls.
Windows utilise le programme Excel courant et renvoie simplement un
lien vers le fichier déjà ouvert par Excel.

En résumé, on utilisera en général :

CreateObject pour créer un nouvel objet. Pour charger ensuite un fichier, on utilisera les fonctions de lecture de fichier proposées par cet objet.

GetObject pour travailler avec un objet lancé préalablement par l'utilisateur.

Dans notre exemple, nous allons donc nous connecter à Excel par la fonction GetObject afin de modifier la feuille de calculs chargée en premier plan par l'utilisateur. En conséquence, lancez Excel et positionnez-vous sur une feuille de calculs.
GetObject renvoie un lien que nous stockerons dans la variable xl. La création d'une variable se fait par l'instruction dim.
Dans automa.hop, tapez : dim xl

Pour nous connecter à Excel, tapez : xl = GetObject ( , "Excel.Application")
Remarque : le nom d'Excel pour Ole Automation est indiqué dans la documentation d'Excel. Il s'agit de "Excel.Application" (voir l'aide vba pour Excel).
Nous obtenons ainsi un lien sur l'objet Application d'Excel. Dans la documentation d'Excel, on trouve la liste des méthodes et des propriétés de l'objet Application :

Une méthode est une fonction qui exécute une opération. Par exemple, la méthode PrintOut imprime un document.

Une propriété est une information que l'on peut lire et parfois écrire. Par exemple, la propriété Visible permet de savoir si Excel est affiché à l'écran (elle vaut true ou false). Mais on peut aussi écrire : Visible = true pour rendre Excel visible ou Visible = false pour mettre Excel en mode caché.

Nous allons maintenant nous connecter à la feuille en cours d'édition. Nous utiliserons pour ce faire la propriété ActiveSheet de l'objet Application, qui renvoie un lien sur la feuille en cours.
Déclarez d'abord une deuxième variable pour y stocker ce lien en tapant : dim fe
Puis opérez la connexion en tapant : fe = xl.ActiveSheet
Remarque : La notation pointée xl.ActiveSheet précise que ActiveSheet est une propriété de l'objet pointé par la variable xl (ici, "Excel.Application").
Le lien que nous venons de créer pointe un objet "Feuille de Calculs" (objet Sheet - Cf. documentation d'Excel pour connaître la liste des méthodes et des propriétés de cet objet).

Il existe par exemple la propriété Cells (ligne , colonne) qui permet de lire et d'écrire dans une cellule. Comme tout à l'heure, nous devrons utiliser la notation pointée pour préciser l'objet concerné par cette propriété.
Tapez : fe.Cells (1 , 1) = "Petit calcul";cellule A1
fe.Cells (2 , 1) = 10;cellule A2
fe.Cells (3 , 1) = 15;cellule A3
fe.Cells (4 , 1) = "=A2+A3";formule de calcul
Attention : il faut mettre un blanc avant et après la virgule pour que DhAutomation sache qu'il s'agit de 2 paramètres et non de la valeur décimale 1,1.
Nous pouvons aussi lire le résultat du calcul avec cette même propriété.
Si nous tapons : fe.cells (4 , 1), nous obtenons la valeur "25" .

La cellule (4,1) contient un résultat mais aussi une formule de calcul. Comment lire la formule plutôt que le résultat ? La documentation d'Excel nous indique que la propriété Cells renvoie en réalité un objet Cellule avec la propriété par défaut Value. Lorsqu'on écrit fe.cells (4 , 1), on ne précise pas le nom de la propriété ou de la méthode à utiliser. Excel utilise alors une propriété par défaut qui ici renvoie la valeur de la cellule.
La commande complète équivalente est : fe.cells ( 4 , 1).Value
Pour obtenir la formule de calcul de la cellule, on tapera : fe.cells (4 , 1).Formula
qui renverra la valeur : "=A2+A3".

La propriété Cells renvoie un objet Cellule. Nous aurions aussi pu déclarer un lien sur l'objet Cellule et écrire :
dim ce;déclaration de la variable
ce = fe.Cells (4 , 1);établissement du lien sur la cellule
ce.Value;accès pour récupérer le résultat du calcul
ce.Formula;accès pour récupérer la formule de calcul

La notation pointée permet aussi de se passer des variables intermédiaires. Exemple :
ce.Formula<=>fe.Cells (4 , 1).Formula
<=>xl.ActiveSheet.Cells (4 , 1).Formula

Maintenant , nous allons imprimer la feuille de calculs par la méthode PrintOut de l'objet Feuille de Calculs. Syntaxe de PrintOut :
PrintOut (from , To , Copies , Preview , ActivePrinter, PrintToFile , Collate)
La documentation nous indique que tous ces paramètres sont facultatifs. On peut donc écrire, pour une impression simple :
fe.PrintOut
Si nous voulons obtenir 3 exemplaires, on écrira :
fe.PrintOut ( , , 3)
ou on utilisera l'affectation de paramètres (opérateur :=).
Exemples :
fe.PrintOut (Copies := 3)
fe.PrintOut (Copies := 3 , ActivePrinter := "nom de l'imprimante")

Pour finir, nous nous déconnectons des objets d'Excel et d'Excel lui-même, en allant du plus "petit" au plus "grand" objet. Les commandes à exécuter sont les suivantes :
ce = null ;on se déconnecte de la cellule (4 , 1)
fe = null ;on se déconnecte de la feuille de calculs
xl = null ;on se déconnecte d'Excel

3. Autre exemples
Mise à jour d'un fichier Excel
dim a
dim b
dim c
a = CreateObject ("Excel.Application")
b = a.WorkBooks.Open (filename := "c:\divalto\sys\test.xls") ;lecture
c = b.WorkSheets (1);on se place sur la 1ère feuille
c.Cells (1 , 1) ;lecture d'une cellule
c.Cells (1 , 1) = "Bonjour";mise à jour de cellules
c.Cells (1 , 2) = 10
rem c.Visible = true ;si on veut rendre apparent Excel
rem a.Visible = true;(rem = commentaire)
c = null ;on n'a plus besoin de c
b.Close (SaveChanges := true);avec sauvegarde des modifs
b = null ;on n'a plus besoin de b
a.Quit ;on sort de Excel
a = null;on n'a plus besoin de a

Exemple avec Word
Chargement d'un fichier, remplacement de textes et impression du document (Cf. documentation de Word dans l'apide vba pour word). Les commandes Ole Automation sont :
dim ww
dim rr
dim ss
dim resul
dim cherche
dim remplace
ww = CreateObject ("Word.application")
ww.Visible = true;word visible
rr = ww.Documents.Open (FileName:= "fichier" );open fichier
ss = rr.content;sélection du texte
Cherche = "valeur à chercher";cherche & remplace
Remplace = "valeur de remplacement"
resul = ss.Find.Execute (FindText := cherche ,
ReplaceWith := Remplace ,
Replace := 2);<=> tout remplacer
resul = rr.PrintOut (Background := false);print en mode normal
ss = null;libération de ss
resul = rr.Close (SaveChanges := 0);close fichier sans
;sauvegarde pour
;conserver l'original
rr = null
ww.Quit (SaveChanges := 0);on arrête Word
ww = null;déconnection de Word

Remarque : Vous trouverez d'autres exemples dans la documentation de Visual Basic. Toutefois, il y a ici quelques différences :

DhAutomation.dll n'est pas un langage complet de programmation. Il ne sert qu'à envoyer des commandes Ole Automation. C'est votre programme DIVA qui doit exécuter l'algorithme de programmation, générer les commandes Ole Automation et les faire exécuter via DhAutomation.

DhAutomation ne gère pas de tableaux ni de structures. Il ne travaille qu'avec des variables simples telles les variables alpha-numériques ou numériques.

DhAutomation ne contient pas la commade With de Visual Basic. Lorsqu'on écrit, dans Visual Basic :

With fe
.Cells (1 , 1) = 10
.Cells (2 , 1) = 20
EndWith
Il faut écrire dans DhAutomation :
fe.Cells (1 , 1) = 10
fe.Cells (2 , 1) = 20

L'appel de la fonction Each est différente. En Visual Basic, on peut écrire :

dim c
For Each c in xl.WorkSheets ;liste des feuilles de calculs
c.Name ;lecture du nom de la feuille
Next c
Dans DhAutomation, il faut écrire :
dim c
dim idx
dim col
col = xl.WorkSheets ;objet liste des feuilles de calculs
Each col idx ;idx contient maintenant un énumérateur de liste
Next idx c ;on récupère le 1er de la liste
c.Name ;lecture du nom de la 1ère feuille
Next idx c ;on récupère le 2ème de la liste
c.Name ;lecture du nom de la 2ème feuille
etc.;tant que Next ne sort pas en erreur

Il existe plusieurs Visual Basic : Le Visual Basic général, langage de programmation pour écrire des applications générales et Visual Basic pour Application, module Visual Basic intégré dans une application comme Word ou Excel. Dans Visual Basic pour Excel, on peut écrire :

dim fe
fe = ActiveSheet
On s'aperçoit qu'il manque l'ouverture de l'objet Excel ainsi que la variable
contenant le lien vers Excel devant le mot clé ActiveSheet. En fait, Visual
Basic pour Excel considère que s'il n'y a rien devant une commande, c'est
qu'on travaille avec l'objet principal (ici Excel) et qu'il est déjà ouvert (car
c'est Excel qui exécute le programme Visual Basic).
Dans DhAutomation, il faut d'abord se connecter à un objet et écrire :
dim xl
dim fe
xl = CreateObject ( "Excel.Application" )
fe = xl.ActiveSheet

II. Liste des instructions de DhAutomation
Remarques préliminaires :

La liste qui suit peut être obtenue par la commande Help du programme automa.dhop, elle est toujours plus complète que la liste ci dessous

indique que le mot clé n'est valable qu'en début de ligne.

Le nom des fonctions peut être écrit indifféremment en minuscules ou en majuscules.

ATTENTION : lorsqu'on passe des paramètres numériques dans une fonction, il faut laisser un blanc autour de chaque virgule. Exemples :
fonction x (1,2);=> il s'agit d'une fonction x avec 1 seul
;paramètre de valeur décimale 1,1
fonction x (1 , 2); => fonction x avec deux paramètres : 1 et 2

Définitions de variables
Dim
Allocation d'une variable (30 variables maximum).
Exemple :
Dim var
var = "bonjour"
var = 128
var = 128.56
var = 128,56
var = -128,56
var = CreateObject ( "Excel.Application" )
Ul1
La variable prédéfinie ul1 contient le chemin de l'unité logique Divalto
numéro 1 (par exemple, c:\divalto).
Exemple :
Dim a
a = fcConcat (ul1 , "\sys\constantes.txt")
LoadConst a
Variant
utilisez dim à la place.
Object
()utilisez *dim à la place.
Array
Declaration d'un tableau , voir la commande HELP dans automa.dhop
Affectations
Set
Affectation (facultatif).
Exemples :
Set a = 10
a = 10
a = "bonjour"
Set a = 'bonjour'
:=
Affectation dans une fonction ou une méthode.
Exemple : obj.Quit (SaveChanges := 0)

Gestion des constantes
Const
Allocation d'une constante.
Exemples :
Const OUI = 1
Const NON = 0
Const FICHIER = "c:\divalto\sys\fichier.txt"
ListConst
Liste des constantes.
FreeAllConst
Supprime toutes les constantes.
LoadConst obj
Charge les constantes d'un objet. Souvent, on trouve des constantes dans
les fonctions des objets. Exemple dans Excel : xlRows, xlWorkSheet, etc.
On peut charger la valeur de ces constantes en faisant :
dim obj
obj = CreateObject ("Excel.Application")
LoadConst obj
ListConst
obj = null
LoadConst fic
Charge les constantes à partir d'un fichier.
Exemples :
LoadConst "c:\divalto\sys\constantes.txt"
Dim a
a = "c:\divalto\sys\constantes.txt"
LoadConst a
SaveConst fic
Sauvegarde les constantes dans un fichier.
Exemple :
dim obj
obj = CreateObject ("Excel.Application")
LoadConst obj
SaveConst "c:\ divalto \sys\constantes.txt"

Création et chargement d'un objet
CreateObject (nom de l'objet)
Création d'un nouvel objet.
Exemple :
dim obj
obj = CreateObject ("Excel.Application")
Le nom des objets est en général du type "nom de l'objet.Application" mais il
peut être en plus référencé dans la base de registres de Windows sous le nom
ou les noms : "nom de l'objet.Application.version".
Exemple :
obj = CreateObject ("Excel.Application.8");=> Excel 97
A utiliser lorsqu'on doit charger impérativement une version précise d'un objet
(par exemple, si on utilise des fonctions qui n'existent que dans cette version).
Si l'objet installé n'est pas de cette version, OU S'IL NE SAIT PAS EMULER CETTE VERSION,
on aura une erreur au chargement indiquant que l'on ne
peut pas se connecter à cet objet.
GetObject (fichier , nom de l'objet)
Chargement d'un objet déjà existant en mémoire ou sur disque.
Le premier paramètre indique le nom du fichier à ouvrir.
Le deuxième paramètre indique le nom de l'objet à ouvrir.
Exemples :
Syntaxe 1
dim obj
obj = GetObject ( "c:\divalto\sys\fichier.xls")
On a indiqué ici uniquement le premier paramètre. Windows charge
l'objet sachant gérer ce type de fichier (il se base sur l'extension du
nom du fichier passé en paramètre ; par exemple, .xls pour Excel).
Windows cherche quel programme lancer dans la base de registres.
Syntaxe 2
dim obj
obj = GetObject ( , "Excel.Application")
On a indiqué ici uniquement le deuxième paramètre. Windows cherche
dans la base de registres quel programme il doit lancer (ici Excel).
Windows vérifie si le programme Excel est déjà chargé en mémoire ;
si ce n'est pas le cas, il renvoie une erreur.
Syntaxe 3
dim obj
obj = GetObject ("c:\divalto\sys\fichier.xls" , "Excel.Application")
On a ici indiqué les deux paramètres, le nom du fichier et l'objet qui le
gère. Cette syntaxe permet de charger un fichier en forçant l'objet à
utiliser. Elle évite une éventuelle ambiguïté lorsque deux logiciels
utilisent la même extension (par exemple, .doc qui est utilisée à la fois
par Wordpad et par Word).

Déconnexion d'un objet
Null
Nothing
Valeur nulle, effacement d'une variable.
Exemple :
obj = Null
obj = Nothing
Attention : Il faut effacer un pointeur sur un objet lorsque vous ne l'utilisez
plus. Ceci permet à un objet de se fermer si plus personne ne l'utilise. Sinon,
on risque de laisser des objets "fantômes" en mémoire.
Exemple :
dim xl
dim fe
xl = GetObject ( , "Excel.Application")
fe = xl.ActiveSheet
fe.cells (1 , 1);lecture de la cellule ligne 1 colonne 1
fe.cells (1 , 1) = "bonjour";mise à jour de cette cellule
fe.cells (2 , 1) = 10
fe.cells (2 , 1) = 20
fe.cells (3 , 1) = "=A2+A3"
fe = null ;commencer par l'objet de plus bas niveau (feuille Excel)
xl = null ;terminer par l'objet de plus haut niveau (objet Excel)

Informations sur un objet
TypeLib obj fic
Copie la liste des méthodes et des propriétés du programme obj
dans le fichier fic.
Exemple :
dim obj
obj = CreateObject ("Excel.Application")
TypeLib obj "c:\divalto\sys\excel.txt"
TypeInfo obj
Affiche la liste des méthodes et des propriétés de l'objet obj.
Exemple :
dim obj
obj = CreateObject ("Excel.Application")
TypeInfo obj
TypeInfo obj fic
Copie la liste des méthodes et des propriétés de l'objet obj
dans le fichier fic.
Exemple :
dim obj
obj = CreateObject ("Excel.Application")
TypeInfo obj "c:\divalto\sys\excel.txt"

Gestion d'une collection d'objets
Une collection est un objet qui contient une liste d'autres objets.
Après avoir créé un pointeur sur l'objet, il faut lui demander le pointeur sur sa liste d'objets.
Each coll index
Next index obj
Each coll index : appel de la liste d'une collection.
Next index obj : appel de l'élément suivant.
Exemple :
dim obj
dim idx
dim fe
dim ww
obj = GetObject ( , "Excel.Application")
fe = obj.Worksheets;pointeur sur la liste des feuilles de calculs
Each fe idx;idx contient un énumérateur de liste
;on peut maintenant récupérer le premier
;élément de la liste
Next idx ww;ww contient le premier objet de la liste
ww.Name;on peut l'utiliser pour lire le nom de la
;feuille de calcul
;lecture de l'élément suivant
Next idx ww;ww contient maintenant l'élément suivant
ww.Name
etc.;tant que Next ne sort pas en erreur

Fonctions sur les chaînes de caractères
Ces fonctions permettent de travailler sur de très longues chaînes.
fcConcat (chaîne , chaîne , chaîne , ... )
Concatène n chaînes de caractères.
fcMid (chaîne , position , longueur)
Renvoie une sous-chaîne en fonction des positions et longueurs indiquées.
fcLeft (chaîne , longueur)
Renvoie les <longueur> caractères de gauche d'une chaîne.
fcRight (chaîne , longueur)
Renvoie les <longueur> caractères de droite d'une chaîne.
fcLength (chaîne)
Renvoie la longueur d'une chaîne.
fcString (chaîne à chercher , chaîne , position)
Renvoie la position d'une chaîne dans une autre (en partant de <position>).

Fonctions sur les valeurs numériques
fcAdd (v1 , v2)
v1 + v2.
fcSub (v1 , v2)
v1 - v2.
fcMul (v1 , v2)
v1 * v2.
fcDiv (v1 , v2)
v1 / v2.
fcEnt (v1)
Partie entière de v1.
fcMin (v1 , v2)
Minimum de v1 et v2.
fcMax (v1 , v2)
Maximum de v1 et v2.
fcTest (v1 , v2)
-1 si v1 < v2 ;
0 si v1 = v2 ;
+1 si v1 > v2.

Fonctions diverses
Help
Appel de l'aide.
Rem
Ligne de commentaires.
Exemple :
Rem ceci est un commentaire
;
Commentaires.
Exemple :
fe = null ;ceci est un commentaire
Version xxx
Demande que DhAutomation utilise la version du langage xxx.
Exemple :
Version 101
Dialog
Avec affichage de la boîte de dialogue des erreurs.
Exemple :
Dialog
NoDialog
Sans affichage de la boîte de dialogue des erreurs.
Exemple :
NoDialog
Lang Francais
Lang Anglais
Code langue à utiliser pour Ole Automation = français ou anglais.
Exemples :
Lang Francais
Lang Anglais
Attention : il faut commencer votre script par Lang francais (ou anglais) si vos
commandes sont en français (ou en anglais). Sinon, l'objet risque de prendre
un autre type de langue lors de son ouverture et de ne pas comprendre les
commandes que vous lui envoyez.
Lang val1 , val2
Code langue à utiliser pour Ole Automation = val1,val2
Exemples : Lang 4 , 9
Lang 0 , 0
Lang 0
Cette commande permet d'indiquer un autre type de langue que Francais ou
Anglais.
True
Renvoie la valeur vrai.
False
Renvoie la valeur faux.
M ou P
m ou p
Force le mode Méthode ou Propriété.
Exemples :
A l'exécution de la commande : obj.Add, si la commande sort en erreur
"Add n'est pas une propriété de l'objet obj"
essayez la commande : obj.Add ( m )
A l'exécution de la commande : obj.Name, si la commande sort en erreur
"Name n'est pas une méthode de l'objet obj"
essayez la commande : obj.Name ( p )
[mot_clé]
Une paire de crochets encadrant un identificateur indique que celui-ci n'est pas
une instruction mais un mot clé de l'objet.
Exemple : Imaginons qu'un serveur ait une fonction nommée CreateObject !
Si on écrit : obj.CreateObject ( ...), DhAutomation sortira une erreur, considérant
que c'est l'instruction CreateObject que l'on veut appeler.
On écrira alors : obj.[CreateObject] ( ...)

III Utilisation de DhAutomation.dll dans un programme DIVA
Le fichier Include zoleaut.dhsp contient les fonctions de chargement de la dll DhAutomation et d'appel des fonctions d'un objet Ole Automation. Le programme automa.dhop permet de taper directement des commandes Ole Automation (Le source du programme automa.dhop se trouve dans le fichier automa.dhsp).

1. Ouverture de la dll DhAutomation
Le chargement de la DhAutomation se fait par la fonction OleOpen. Exemple :
include zoleaut.hsp
1 mess 256
1 i X
i = OleOpen;open de DhAutomation
if i <> 0
display "Erreur open Ole Automation"
i = OleMessage(mess);récupère le texte du message d'erreur
display left (mess,length(mess))
i = OleClose;ATTENTION, il faut qd même refermer DhAutomation
ProgramExit
endif

On peut afficher le numéro de version de DhAutomation.dll et celui du langage par :
display "Version de DhAutomation.dll " 0
display OleVersionDll
display "Version du langage " 0
display OleVersionLang

2. Exécution d'une commande Ole Automation
L'exécution d'une commande Ole Automation se commande par la fonction OleExec.
Exemple :
1 buffer 256
buffer = "texte de la commande"
i = OleExec (buffer)
if i <> 0
;le code de l'erreur se trouve dans OleErr
i = OleMessage(mess)
display left(mess,length(mess))
else
...
endif

3. Affichage du résultat d'une commande
On peut chercher le résultat d'une commande par la fonction OleExecResult.
Exemple :
1 buffer 256 ;lg maximum d'une ligne de commande
1 mess 256 ;lg maximum d'une ligne de message
1 resultat 256 ;lg maximum d'une ligne de résultat
1 taille 13,0
1 taille2 13,0
buffer = "texte de la commande"
i = OleExec (buffer)
if i <> 0
;le code de l'erreur se trouve dans OleErr
i = OleMessage(mess)
display left(mess,length(mess))
else
i = OleExecResult(mess,resultat,taille,taille2)
if i <> 0
display "Resultat [" & left(resultat,length(resultat)) & "]"
display "Type du résultat [" & left(mess,length(mess)) & "]"
display "Taille du résultat [" & taille & "]"
display "Lg réelle du résultat [" & taille2 & "]"
endif
endif
La longueur maximale d'un résultat dans DhAutomation est par defaut de 256 caractères,
Mais on peut l'agrandir a volonté, en agrandissant les champs et en mettant
OleLgMaxi256 = taille maxi de votre buffer
La fonction OleExecResult renvoie le type du résultat :
0 = pas de résultat
1 = numérique
2 = alpha-numérique
3 = date
4 = code d'erreur
5 = pointeur objet de type DISPATCH (interface vers un objet)
6 = booléen
7 = pointeur objet de type UNKOWN (idem 5 mais vers un interface non connu)
autre = inconnu ou sans signification pour le programme DIVA.

4. Fermeture de la dll DhAutomation
Après avoir exécuté les commandes Ole Automation, il faut décharger la dll DhAutomation par la fonction :
i = OleClose

5. Liste des erreurs
Erreurs au chargement de la dll (la fonction OleMessage permet de récupérer le texte de l'erreur) :
1 - Erreur Ole x Ole non initialisé.
2 - Erreur Ole x La version de compobj.dll n'est pas valide pour la dll Ole2.dll.
3 - Erreur Ole x Plus de mémoire.
4 - Erreur Ole x Argument invalide.
5 - Erreur Ole x Erreur inconnue.

Erreurs à l'exécution d'une commande Ole Automation (la fonction OleMessage permet de récupérer le texte de l'erreur) :
1 - Erreur Ole x Ole non initialisé
2 - Plus de mémoire
3 - Erreur Ole x Impossible de créer l'objet (CreateObject)
4 - Il manque un paramètre
5 - Fin de ligne rencontrée trop tôt
6 - Texte trop grand
7 - Caractère ou mot inconnu
8 - Variable inconnue
9 - Nom de variable trop grand (maxi=31)
10 - Table des variables pleine (32 variables maximum)
11 - Pile de travail pleine (32 niveaux)
12 - Mot clé ou constante texte attendue
13 - Erreur Ole x Erreur dans la fonction get dispatch
14 - Variable attendue
15 - Pointeur sur un objet attendu
16 - Constante texte attendue
17 - Affectation impossible
18 - Erreur Ole x Erreur dans la fonction propertyput
19 - Fonction ou mot clé non implémenté
20 - Nombre de paramètres faux
21 - Constante numérique attendue
22 - Variable déjà définie
23 - Variable portant le même nom qu'un mot clé
24 - Code Langue inconnu
25 - Constante numerique simple ou texte attendu
26 - Erreur Ole x Erreur à l'appel de next
27 - Erreur %d pointeur UNKOWN attendu
28 - Erreur Ole x Erreur à l'appel de each
29 - Erreur %d Erreur Ole x pointeur Enum attendu
30 - Plus d'objet dans la fonction next
31 - Erreur Ole x Impossible de trouver l'objet (GetObject)
32 - Erreur Ole x Impossible de créer l'objet (CreateObject)
33 - Erreur Ole x Impossible de créer l'objet (CreateObject)
34 - Erreur Ole x Impossible de créer l'objet (CreateObject)
35 - Erreur Ole x Impossible de trouver l'objet (GetObject)
36 - Erreur Ole x Impossible de trouver l'objet (GetObject)
37 - Erreur Ole x Impossible de trouver l'objet (GetObject)
38 - Erreur Ole x Impossible de trouver l'objet (GetObject)
39 - Erreur Ole x Impossible de trouver l'objet (GetObject)
40 - Erreur Ole x Impossible de trouver l'objet (GetObject)
41 - Erreur Ole x Impossible de trouver l'objet (GetObject)
42 - Erreur Ole x Impossible de trouver l'objet (GetObject)
43 - Erreur Ole x Impossible de trouver l'objet (GetObject)
44 - Erreur Ole x Impossible de trouver l'objet (GetObject)
45 - Erreur Ole x Impossible de trouver l'objet (GetObject)
46 - Version langue incompatible (version langue xxx)
47 - Type de paramètre invalide
48 - Erreur x à l'ouverture du fichier x
49 - Erreur Ole x Impossible de charger la description de cet objet
50 - Erreur Ole x Impossible de charger la description de cet objet
51 - La syntaxe de Const est Const motcle = valeur
52 - Une constante ne peut être que de type texte ou numérique
53 - La syntaxe de Const est : Const motcle = valeur
54 - Cette constante existe déjà
55 - Mot clé Const attendu
62 - Variable vide
autre - Erreur Ole x Erreur inconnue
Cas particulier des erreurs 26 (Erreur Ole x Erreur à l'appel de next) et 30 (Plus d'objet dans la fonction next) : il ne s'agit pas forcément d'une erreur, ces codes indiquent simplement qu'il n'y a plus d'objet dans la liste des objets en lecture d'une collection d'objets.