[Ceci est une documentation préliminaire sujette à modifications]

Liogo partout

Le Logo est un puissant langage de programmation dynamique, il peut être intéressant d'utiliser la puissance du langage Logo depuis d'autres applications. C'est exactement ce que vous permet Liogo par l'intermédiaire de son interface OLE Automation.

OLE Automation est une manière pour une application Windows d'exposer ces fonctionnalités aux autres applications. Beaucoup d'applications peuvent appeler des interfaces OLE Automation. Les plus célèbres sont les applications Office (par l'intermédiaire du langage Visual Basic pour Application) et les lignes de commande VBScript. Je vais vous montrer dans cette leçon comment utiliser Liogo depuis ces applications. Notez que OLE Automation n'est pas disponible sous Linux.

Avant de continuer cette leçon, vous devez vous assurer que l'interface OLE Automation de Liogo est installée sur votre PC. Le module est installé lorsque vous choisissez une installation "Complète" ou quand l'option "Développeur" est sélectionnée dans l'installation "Personnalisée" (voir la figure ci-dessous). Si vous n'avez pas choisi cette option à l'installation, relancez l'assistant d'installation pour mettre à jour votre installation.

Démarrer le runtime Liogo

L'interface Liogo OLE Automation est exposée par l'intermédiaire d'un objet COM appelé "Liogo.Application". Pour appeler Liogo, vous devez tout d'abord créer un objet "Liogo.Application". Voici comment le créer depuis VBScript:


var liogo = CreateObject("Liogo.Application")

Ici, l'objet est créé puis affecté à une variable VBScript "liogo".

La première chose à faire est maintenant d'initialiser le runtime Liogo. Il vous suffit pour cela d'appeler la méthode Initialize sur votre objet Liogo.


liogo.Initialize("")

La méthode Initialize prend un paramètre utilisé comme chaîne de configuration. Nous verrons à quoi elle est utilisée un peu plus loin. Pour l'instant, nous n'avons pas besoin d'une configuration spécifique, nous allons donc utiliser une chaîne vide.

Trois méthodes vous permettent de communiquer avec le runtime Liogo:

Voici un exemple très simple de programme VBScript appelé "oletest.vbs" qui utilise les méthodes que nous venons de décrire. Notez que les numéros de lignes ont été ajoutée pour faciliter la lecture:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
' Appel de Liogo en utilisant OLE Automation

Set liogo = CreateObject("Liogo.Application")
liogo.Initialize("LIOGO.Culture.Core=fr;LIOGO.Culture.UI=fr")

liogo.Execute("écris """&"Bonjour| |Liogo")

liogo.SetVar "w", 6

wscript.Echo liogo.Execute("somme :w 2")

wscript.Echo liogo.GetVar("w")

liogo.Terminate()

La Ligne 6 utilise Execute pour appeler la méthode "écris" du Logo et afficher un message de bienvenue. Notez que vous devez utiliser les quotes du Logo pour manipuler les constantes chaines de caractères.

La Ligne 8 appelle SetVar pour changer la valeur de la variable Logo "w" de la ligne 6. Cette ligne est équivalente de la commande Logo:


donne "w 6

La Ligne 10 utilise Execute pour réaliser une opération arithmétique sur la variable Logo "w". Le résultat de l'opération est affiché en utilisant la fonction VBScript Echo. Plutôt que d'être affiché, le résultat aurait tout aussi bien être placé dans une variable VBScript.

La Ligne 12 utilise SetVar pour récupérer la valeur de la variable Logo "w".

A propos des types

Chaque fois qu'une donnée est échangée entre Liogo et VBScript, une conversion est nécessaire. Dans l'exemple précédent, seules des données numériques sont utilisées: en ligne 8, un nombre VBScript est converti en un nombre Logo et inversement en ligne 10 et 12, un nombre Logo est converti en un nombre VBScript.

L'interface OLE Automation de Liogo converti automatiquement les données Logo dans le type multi-usage de COM appelé "Variant". La table ci-dessous donne les équivalents entre le Logo et le type Variant.

Logo value
Nom du type Valeur LogoValeur Variant
Nombre110110
Mot"Hello'Hello'
Liste[A B C]Array("A", "B", "C")
Tableau{A B C}Array("A", "B", "C")
Listes ou tableaux imbriqués    [[1 2 3] [4 5 6]    Array(Array(1, 2, 3), Array(4, 5, 6))

Carré magique

Les feuilles Excel et en particulier les formules Excel sont d'excellents endroits pour utiliser Logo. Et comme Liogo gère automatiquement les conversions avec des tableaux, c'est facile d'utiliser une expression Logo pour renseigner ou récupérer les valeurs d'un ensemble de cellules.

Voici ci-dessous un fichier Excel appelé "carrémagique.xls" qui utilise Liogo pour calculer un Carré Magique.

Comme vous le savez probablement, un carré magique est un arrangement de nombres dans un carré de telle sorte que les nombres en lignes, colonnes et diagonales valent la même somme. Dans cet exemple, une partie du carré est remplie en utilisant Liogo, l'autre partie est remplie en utilisant Excel.

Le Nombre 1 sur le schéma précédent montre comment est initialisée la première ligne en utilisant une liste Logo. Voici le code VBA derrière 1:

Range("B5:E5").Value = liogo.Execute("(liste 1 12 8 13)")

Le Nombre 2 sur le schéma montre comment on peut calculer la somme d'une ligne Excel en Liogo. Le code source VBA est:

liogo.SetVar "c", Range("B5:E5").Value
Range("F5").Value = liogo.Execute("réduire ""somme premier :c")

Le Nombre 3 sur le schéma montre comment initialiser un ensemble de lignes en une seule fois:

Range("B5:E5").Value = liogo.Execute("(liste [11 2 14 7] [16 5 9 4])")

Pour finir, le Nombre 4 sur le schéma est une opération sur un ensemble de colonnes:

liogo.SetVar "c", Range("B5:B8").Value
Range("B9").Value = liogo.Execute("réduire ""somme premiers :c")

Gestion des erreurs

Quelque fois votre code Logo peut être erroné. Les erreurs classiques sont l'appel d'une procédure inexistante ou lorsque vous essayez de récupérer la valeur d'une variable qui n'a pas été initialisée. Deux méthodes permettent de gérer ces cas d'erreur depuis l'interface OLE Automation: GetErrorId et GetErrorText. Voici un exemple d'appel de ces méthodes:

liogo.Execute("écris somm 3 5")
if liogo.GetErrorId() <> -1 then
    wscript.Echo liogo.GetErrorText()
end if

v = liogo.GetVar("xyz")
if liogo.GetErrorId() <> -1 then
    wscript.Echo liogo.GetErrorText()
end if

La méthode GetErrorId est utilisée pour récupérer le code de la dernière erreur qui s'est produite. La méthode retourne -1 quand aucune erreur ne s'est produite.

La méthode GetErrorText est utilisée pour récupérer le message d'erreur. Une chaine vide est retournée lorsque aucune erreur ne s'est produite.

Procédures utilisateur et performances

Comme Liogo est un compilateur Logo, chaque fois que vous utilisez la méthode Execute, Liogo appelle le compilateur. Bien sûr il peut être pénalisant pour les performances d'appeler plusieurs fois le compilateur à l'exécution. Il y a deux manières d'éviter cela.

D'abord, vous pouvez faire en sorte d'utiliser chaque fois la même chaine comme paramètre de la méthode Execute. Le script suivant calcule une approximation de la valeur de PI en utilisant les commandes graphiques de Logo.

    Dim n As Integer
    n = 10
    For i = 6 To 16
        liogo.SetVar "n", n
        liogo.Execute "origine nettoietout répète :n [avance 1 droite 180/:n] donne ""r 2*:n/(premier pos)"
        Range("B" & i).Value = n
        Range("C" & i).Value = liogo.GetVar("r")
        n = n * 2
    Next i

Dans la boucle VBA, vous remarquez que l'on utilise des variables Logo pour la boucle et pour le résultat. Cette astuce nous permet d'exécuter systématiquement la même chaine de caractères alors que les valeurs changent. Comme Liogo gère en interne un "cache" des commandes, le compilateur est appelé uniquement la première fois.

Une autre manière d'optimiser les performances et d'appeler vos propres DLLs. Prenons une fois de plus la DLL "fact.dll" que nous avons généré dans la leçon Premiers pas avec Liogo. Pour charger cette DLL, vous avez simpler à appeler la commande Logo "charge".

liogo.Execute "charge ""fact"
wscript.Echo liogo.Execute("fact 10")

Notez qu'il y a actuellement une limitation à ce mécanisme et qu'il est nécessaire que les DLLs utilisées de cette manière soient copiées dans le répertoire %SYSTEMROOT%\SYSTEM32 de votre PC (généralement C:\WINDOWS\SYSTEM32).

Configuration de votre application OLE

Si vous avez lu la leçon Déployer et personnaliser, vous savez déjà qu'il est possible de personnaliser une application Liogo. Il n'est pas possible d'utiliser un fichier de configuration lorsque vous utilisez Liogo depuis OLE. Cependant, l'interface OLE de Liogo vous permet de spécifier les options de configuration comme paramètre de l'appel de la méthode Initialize. Dans l'exemple suivant, nous utilisons la configuration pour changer la langue pour les messages et le langage Logo.

 
	var liogo = CreateObject("Liogo.Application")
	liogo.Initialize ("LIOGO.Culture.Core=fr;LIOGO.Culture.UI=fr")

Bien sûr tous les paramètres décrits dans Référence des paramètres de configuration peuvent être changés de la même manière.