Dans cette leçon, nous allons introduire deux notions très importantes, et surtout pratiques du Lua : créer une table, et récupérer une variable d’une application TI-Nspire vers un script en Lua. Nous allons aussi rencontrer les boucles « For ». Si vous débutez en programmation, je vous recommande fortement de vous familiariser avec cette boucle dans d’autres langages, par exemple en TI Basic, avant de tenter ce genre de choses en Lua.A nouveau nous utiliserons Oclua pour créer et tester les scripts vus lors de ce cours, seulement pour notre confort. Les scripts en Lua peuvent être écrits dans n’importe quel éditeur de texte (De NotePad à Word, en passant par le bloc-notes). Pour les utilisateurs de windows, la gratuité de NotePad++ en fait un excellent choix pour ce genre de travail car il colore le texte et participe à la structure de votre script. Pour les utilisateurs de Mac, Xcode est sur votre CD d’installation sous les Outils Développeurs, et fera parfaitement l’affaire. Si vous êtes prêts à dépenser quelques euros, TextMate est excellent (et « connaît » même le Lua ce qui peut aider pour la syntaxe et les bugs).
Mais alors, pour quoi ne pas garder Oclua ? Eh bien, le document peut seulement être lu. Lorsque vous créez une page en Lua en collant votre script, tout semble normal. Cependant, fermez et ré ouvrez votre document (même après avoir enregistré) et vous revoilà devant la page vide « Paste your script here ». Ainsi, ce programme est génial pour apprendre et tester les scripts, mais si vous avez besoin d’utiliser un script à n’importe quel moment, vous aurez besoin de TI-Nsipre Scripting Tools, dont nous reparlerons dans la prochaine leçon. En attendant, nous continuerons avec Oclua. Dans la dernière leçon, nous avons découvert les variables locales, et la création de w et h qui représentent la largeur et la hauteur de la fenêtre. Ces variables s’ajustent dynamiquement. Ainsi, si vous passez de la vue en mode ordinateur à la vue calculatrice, ou si vous redimensionnez ou partagez la fenêtre, alors les variables s’adapteront. Utiliser ces variables plutôt que des valeurs statiques signifie que votre page aura le même affichage, quelle que soit la fenêtre.
Dans cet exemple, nous commencerons par définir deux nouvelles variables locales : La table, grâce à des accolades vides (comme sur TI-Nspire), et le nombre de lignes.
Leçon 2.1 : La boucle For en Lua
Comme je l’ai dit précédemment, je suppose que vous avez déjà eu l’occasion de rencontrer la structure “For…End” (Elle s’appelle “For…EndFor” sur TI-Nspire. En Lua, les fonctions de contrôle se terminent toutes par End)
Boucle sur TI-Nspire
For k, 1, 10 var := k* (k+1) EndFor |
Boucle en Lua
for k = 1, 10 do var = k* (k+1) end |
Le résultat de ces deux boucles est identique : à la fin, la variable var vaudra 110. La syntaxe en Lua est similaire à celle de la TI-Nspire. Au lieu d’utiliser For k, de, à, [pas] sur TI-Nspire, le Lua remplace la première virgule par un égal, le mot “do” apparaît à la fin de la ligne de définition, et enfin, veillez à ce que tout soit en minuscules. Le pas est [optionnel] dans les deux cas.
Nous allons maintenant nous appuyer sur un script qui nous servira d’exemple dans la suite de ce cours.
function on.paint(gc) local h = platform.window:height() local w = platform.window:width() local table = {} local nbligne = 3 gc:setFont("sansserif","r",10) gc:setColorRGB(158,8,5) for k = 1, nbligne do table[k] = "Ligne #"..k strheight = gc:getStringHeight(table[k]) strwidth = gc:getStringWidth(table[k]) gc:drawString(table[k], w/2-strwidth/2, h*k/(nbligne + 1) + strheight/2) end end |
Dans cet exemple, nous irons de k = 1 à k = 3, en affichant chaque ligne au fur et à mesure. Les possibilités de cette structure sont assez évidentes – ici, on peut facilement afficher 10 lignes, ou n’importe quel nombre …
Vous avez peut-être reconnu les quelques ligne de l’exemple précédent : lignes qui définissent la police, la couleur, la largeur / hauteur de la chaîne de caractères, et enfin qui affiche le string. Ici, on ajoute une ligne qui crée chaque ligne de notre table. Histoire de bien mettre les choses au clair, la syntaxe table[k] fait référence au k-ème élément de la table. Donc table[1] est la première “ligne” ou “rangée” ou quoi que ce soit qui vous permette de visualiser. Cela fonctionne exactement de la même façon que sur TI-Nspire.
Leçon 2.3 : Créons des lignes pour notre Table !
Pensons un instant à l’organisation d’une table sur TI-Nspire. On la définirait ainsi :
table := { "un", "deux", 7 } |
Maintenant, si on utilisait table[1], on obtiendrait “un”, et pour table[3], on obtiendrait la valeur 7. En Lua, la même chose se produirait. En fait, le Lua est même un peu plus flexible dans la maniabilité des variables. Sur TI-Nspire, il faut bien faire attention à distinguer le string “7” du chiffre 7. Ces deux variables ont une structure de données différente. En Lua, cela n’a pas d’importance, tant qu’elles sont utilisées de manière adéquate. Donc même si vous utilisez une variable num qui contient le string “7”, le Lua peut parfaitement l’utiliser en tant que chiffre, avec par exemple 2*num qui va donner 14. En revanche, si num contenait “sept”, le calcul serait impossible, car on ne peut évidemment pas multiplier un string par un nombre.
Revenons en à notre exemple : on crée en fait chaque ligne de notre table au fur et à mesure que le programme progresse. Quand k = 1, alors table[1] est défini comme la concaténation (Mot barbare, la mise bout à bout de deux chaînes) grâce aux deux points “..” du string “ligne #” et de la valeur de k (1). Donc, table[1] = “ligne#1”. Facile !
Leçon 2.4 : Plaçons ces nouvelles lignes !
Créer toutes ces lignes est plutôt facile. Mais nous devons un peu réfléchir et calculer avant de les afficher correctement. On les centrera horizontalement, comme on l’a déjà fait. Cependant, nous devons les espacer de la même façon verticalement. En d’autres termes, nous devons diviser notre hauteur de fenêtre (h) par un plus le nombre de ligne (1 – nbligne) – car on place en fait les espaces entre les lignes ! Une fois que l’on a compris ceci, le calcul devient plus simple : h*k / (nbligne + 1).
Un petit exemple pour bien comprendre : On veut afficher 3 lignes.
– On aura la première à 1*h / 4
– La deuxième à 2*h / 4 (qui donne h/2)
– La dernière à 3*h / 4
On peut encore faire mieux ! Comment me direz-vous ? En ajoutant la moitié de la hauteur du string ! (h*k / (nbligne + 1) + strheight / 2) Les lignes seront maintenant parfaitement alignées !
________________________
Wow ! On a déjà parcouru un long chemin depuis vos débuts ! Prenez une pause ! Je vous conseille d’essayer de comprendre ce qui se passe plus haut. Modifiez, touchez à tout, comprenez ! On apprend toujours par ses erreurs !
Vous êtes maintenant prêts pour ma dernière partie de ce cours ! On va rendre le tout dynamique !
________________________
Leçon 2.5 : Donnons vie à nos lignes !
Avant de commencer, un petit rappel : un affichage dynamique est par définition le contraire d’un affichage statique. C’est-à-dire qu’un affichage dynamique va s’ajuster grâce à différents paramètres, par exemple un ou plusieurs changements dans une / des variable(s) ; alors qu’un affichage statique ne change pas. (Il porte bien son nom !)
Revenons-en à nos moutons. Nous allons commencer par diviser notre écran (sur le Ti-Nspire Computer Software, en allant dans DOC, et choisir le partage vertical), ensuite dans une des deux parties, nous allons créer un curseur grâce à l’application géométrie.
Après avoir choisi cette application, allez dans Menu > Actions > Insérer un curseur. Ensuite, placez le où vous voulez. Click droit sur le curseur, puis choisissez les paramètres du curseur :
– Variable : lignes
– Valeur : 5 (Cela n’a pas d’importance)
– Minimum : 1
– Maximum : 5
– Incrément : 1
– Style : vertical
Pour une meilleure apparence (optionnel !), click droit sur le curseur, puis choisissez réduire avec le style vertical.
Créer ce curseur est un jeu d’enfant. Mais à quoi ça sert si on ne l’utilise pas dans un script en Lua ? Une solution très simple existe. Elle s’appelle var.recall. Cette commande va nous permettre de remplacer la valeur fixe de nbligne par une valeur dynamique, celle du curseur. On va donc utiliser :
local nbligne = (var.recall("lignes") or 1) |
Ici, var.recall recherche une variable appelée “lignes” et attribue sa valeur à nbligne. (Si la variable lignes existe bien sur) Sinon, elle attribue la valeur 1 – pour ne pas faire planter le programme dans le cas où lignes n’existe pas. Cool.
Et maintenant ?
Bravo ! Ainsi s’achève la deuxième leçon. Prenez un peu de temps pour assimiler toutes ces nouveautés avant de passer à la suite.
Dans la prochaine leçon, on verra comment modifier le contenu de ces lignes, car je suppose qu’obtenir un alignement de “ligne#1”, “ligne#2”, etc ne vous sera que de faible utilité ! 😀