.\ Liste et description des fonctions
• Conventions
Afin de simplifier la présentation, la liste des fonctions et de leurs
arguments est à comprendre de la façon suivante :
• Le nom de la fonction est indiqué comme ceci
• Les arguments sont présentés après les deux points ::
• Ceux entre guillemets "" sont des chaines de caractères
• Ceux sans les guillemets sont des nombres entiers positifs ou négatifs
• Les arguments entre crochets [ ] sont facultatifs
• Les arguments entre accolades { / } sont à comprendre
comme "soit l'un, soit l'autre".
Une fonction présentée comme : fonc :: "var", type,
[ mode ] s'appelle "fonc", et doit être suivie d'une chaine de caractère, d'un nombre,
et d'un second nombre facultatif. Son appel peut donc par exemple ressembler à
vertel("fonc","texte",1) ou encore vertel("fonc","chaine",2,4).
Notez que même un argument numerique non-facultatif n'a pas besoin d'être
indiqué si sa valeur est nulle, puisque tous les arguments numeriques omis sont fixés à 0 par
défaut (voir "Extensions de la syntaxe" sous "Utilisation de la librairie").
• Fonctions graphiques
bufr :: aucun argument
Cette fonction permet d'utiliser un buffer, ou écran
virtuel, aux usages multiples. Il peut à la fois servir pour effectuer des operations
graphiques invisibles pour l'utilisateur (affichage et sauvegarde de PIC découpés, par
exemple), mais aussi et surtout pour appeler plusieurs instructions graphiques et afficher
leur résultat en une seule fois.
Le premier appel de la fonction crée l'écran virtuel et redirige toutes les fonctions
d'affichage sur lui. En appellant une seconde fois la fonction, le buffer sera recopié à
l'écran.
Notez que la seule façon de concerver le contenu du buffer entre deux appels de Vertel est de
le sauvegarder (voir fonctions "pict" et "save").
clrs :: aucun argument
Effectue un Clear Screen, autrement dit efface totalement
l'écran. Cette fonction diffère de celle du Ti-Basic en plusieurs points : Vertel ne considère
pas plusieurs écrans (Home, I/O, Graph...) mais un seul; de plus l'effaçage affecte tout
l'écran et ne laisse ni la barre de menu en haut ni la status line en bas.
crcp :: x, y, rx, ry [, mode]
Dessine un cercle plein de centre x,y. Il s'agit plus
exactement d'une ellipse, dont le rayon du demi-axe horizontal est rx et celui du vertical
ry.
Le mode est 0 pour un cercle noir, 1 pour un cercle blanc, et 2 pour un cercle inversé.
crcv :: x, y, rx, ry [, mode]
Même fonction que crcp, mais pour un cercle vide. Les
arguments sont identiques.
line :: x1, y1, x2, y2 [, mode]
Trace une ligne entre les positions x1,y2 et x2,y2. Peu
importe si le premier point est supperieur, inferieur, à gauche ou à droite du premier.
Les modes possibles sont 0 pour une ligne noire, 1 poir une ligne blanche, 2 pour une ligne
inversée, et 3 pour une ligne à épaisseur double.
pict :: "var", x, y [, mode]
Affiche l'image de type PIC "var" à la position x,y. Il
est possible d'afficher l'image hors de l'écran : la fonction est clippée, mais en raison d'un
bug de AMS, le clipping fonctionne mal avec des images de grandes dimentions.
Les modes sont 0 pour afficher normalement en "OU" logique (comme rclpic), 1 pour écraser le
fond (comme rplcpic), 2 pour du négatif, 3 pour afficher en inversé, "OU" exclusif (comme
xorpic), et 4 pour afficher en "ET" logique (comme andpic).
Si le mode vaut -1, au lieu d'afficher l'image, la fonction retourne ses dimentions en largeur
et hauteur.
pixl :: x, y [, mode]
Cette fonction a un double emploi, comme "pict". Elle
peut modifier l'état d'un pixel aux coordonnées x,y : l'allumer si le mode vaut 0, l'éteindre
si le mode vaut 1, ou l'inverser si le mode vaut 2.
Si le mode vaut -1, la fonction ne modifie rien mais renvoie l'état du pixel situé à la
position x,y sur l'écran (0 si il est éteint, 1 si il est allumé).
recp :: x1, y1, x2, y2 [, mode]
Trace un rectangle plein, dont les coins supperieur gauche
et inferieur droit sont respectivement situés aux positionx x1,y1 et x2,y2. Attention, la
fonction n'affichera rien si les coins sont inversés.
Les modes sont 0 pour afficher le rectangle en noir, 1 pour l'afficher en blanc, et 2 pour
l'afficher en inversé.
recv :: x1, y1, x2, y2 [, mode]
Trace un rectangle vide, entre les coins x1,y1 et x2,y2.
Attention, "recv" a un fonctionnement particulier pour les modes. Plusieurs valeurs sont
disponibles pour divers effets, et il est possible de les combiner. Attention, si le mode vaut
0 (et donc si il est omis), cette fonction n'affichera rien contrairement à toutes les autres
qui affichent par défaut en mode normal (ou en noir).
Les modes cumulables sont : 0 (blanc), 1 (noir), 2 (inversé), 32 (coins arrondi), 64
(épaisseur double), 128 (coins supperieurs coupés). Un mode à 97 (1 + 32 + 64) affichera donc
un rectangle noir, d'épaisseur double, et avec les coins arrondis.
save :: "var", x1, y1, x2, y2
Sauvegarde la portion d'écran comprise entre les coins
x1,y1 et x2,y2 dans la variable "var" qui sera de type PIC (affichable avec "pict", ainsi
qu'avec les fonctions d'AMS).
Notez que la contrainte de "recp" se retrouve ici : le 1er coin doit être au dessus et à
gauche du second.
trip :: x1, y1, x2, y2, x3, y3 [, mode]
Dessine un triangle plein de sommets x1,y1, x2,y2, et
x3,y3.
De nombreux modes sont disponibles; utilisez 0 pour afficher le triangle en noir, 1 pour
l'afficher en blanc, 2 pour l'inverser, 3 pour l'afficher en lignes verticales, 4 en lignes
horizontales, 5 en lignes obliques descendantes, et 6 en lignes obliques montantes.
• Fonctions executables
offp :: aucun argument
Cette fonction éteint simplement la calculatrice. En
utilisant cette instruction dans un programme, au prochain allumage il reprendra son execution
là où il en était. Notez aussi qu'éteindre la calculatrice réinitialise certains parametres
comme le délai et la fréquence de répetition des touches.
paus :: aucun argument
Cette fonction est comparable à "pause" d'AMS : elle
stoppe le programme tant que l'utilisateur n'a pas appuyé sur une touche. Elle possède
néanmoins quelques avantages : elle permet de faire une pause au milieu d'un appel de Vertel,
sans la quitter; elle ne réaffiche pas l'indicateur "pause" de la status line, et elle
retourne la valeur de la touche appuyée (les codes sont les mêmes que la fonction "getkey",
sauf pour les fleches).
retr :: "var" [, mode]
Certaines fonctions retournent des valeurs, "retr" est
la fonction qui permet de les récupérer dans une ou plusieurs variables Ti-Basic. Toutes les
valeurs mémorisées dans Vertel seront ainsi placées dans une variable de type LIST, de la
première à la dernière.
Par exemple l'appel vertel("paus","","retr","key") attend une pression de touche (voir
fonction "paus") et retourne la valeur de la touche appuyée dans la variable "key". Si
l'utilisateur a appuyé sur la touche ENTER (valeur 13), la variable "key" contiendra {13}.
Si le mode est différent de 0, au lieu de retourner une liste de toutes les valeurs, Vertel
retourne uniquement une seule valeur (celle enregistrée en mode-ième position) dans une
variable simple (de type EXPR ou STR, suivant le type de la valeur à retourner), puis
l'efface de sa mémoire interne.
Par exemple l'appel vertel("vers","","paus","","retr",{"var1","var2"},1), si l'utilisateur
appuie sur ESC (valeur 264) au moment de "paus", placera "3.00 ß4" dans la variable "var1" et
264 dans la variable "var2" (on renvoie bien deux fois de suite la valeur de rang 1 : en effet
après avoir retourné la "3.00 ß4" dans "var1", cette valeur est effacée de la mémoire interne,
et les suivantes sont décalées, la nouvelle valeur en 1ere position est donc 264).
time :: [ delai ]
Pour mesurer des durées, "time" utilise un compteur
interne de la Ti qui a une fréquence d'environ 19 tics par seconde. Si l'argument délai est
fixé en indiquant une valeur, le compteur est initialisé à cette valeur. Il sera ensuite
décrémenté 19 fois par seconde, jusqu'à retomber à 0.
Le fait d'appeler la fonction sans indiquer de délai retourne la valeur courante du compteur,
permettant ainsi par une simple soustraction de calculer des durées assez précisement.
vers :: aucun argument
Retourne la version de Vertel, soit actuellement "3.00 ß4".
Ceci permet par exemple de tester la version de Vertel avant d'executer un programme, afin
d'éviter les incompatibilités avec d'autres versions. Cette portion de code peut servir
d'exemple :
local ver
vertel("vers","","retr","ver",1)
try
mid(ver,1)
else
""->ver
endtry
if ver=/="3.00 ß4" then
text "Erreur : Version de Vertel incompatible"
stop
endif
wait :: delai
Met le programme en attente pour "delai" 19emes de
seconde (l'unité est la même que pour la fonction "time"). Le délai 0, qui correspond à une
durée infinie, est désactivé.
• Fonctions de reglages
apdt :: delai
Change la valeur de l'APD Timer (Automatic Power Down,
délai avant extinction automatique de la calculatrice). Le délai est en 19emes de seconde,
comme les fonctions "time" et "wait". Si le délai vaut 0, l'APD est désactivé.
brek :: mode
Active ou désactive la possibilité de provoquer un "break"
du programme en appuyant sur la touche ON. Cette possibilité sera désactivée si le mode vaut 0
et activée si le mode vaut 1. Attention, l'effet est souvent de courte durée car annulé par
une grande quantité de fonctions Ti-Basic, comme par exemple "string()".
clip :: x1, y1, x2, y2
Change la zone de clipping, qui affecte quasiment toutes
les fonctions graphiques. Cette zone correspond en fait à la portion d'écran (par défaut,
l'écran complet) dans laquelle les fonctions graphiques sont visibles.
Attention, la zone de clipping est réinitialisée dès que l'appel de Vertel prend fin.
cntr :: [ mode ]
Si le mode est absent, la fonction retourne la valeur du
contraste (une valeur entre 0 et 31). Si mode vaut 0, elle baisse le contraste d'un ton, et
si il vaut 1 elle l'augmente d'un ton.
keyi :: delai
Change le délai avant l'initialisation de la répetition
des touches (par défaut : 336). La fonction retourne la valeur précedente.
Attention, la valeur par défaut sera rétablie dès que la calculatrice sera éteinte.
keyr :: delai
Change la fréquence de repetition des touches (par défaut :
36). La fonction retourne la valeur précedente.
Attention, comme pour "keyi", la valeur par défaut sera rétablie dès que la calculatrice sera
éteinte.
locl :: niveau
Permet de lire et de modifier les variables locales des
programmes "parents" de celui qui lance Vertel. Si le niveau est 1, par exemple, Vertel
essaiera de trouver les variables requises (avec des indirections internes, par exemple) 1
programme en arrière par rapport à celui qui appelle la librairie.
Lisez cette portion de code pour comprendre le fonctionnement :
local sub,var
define sub()=prgm
local n
input "Valeur ?",n
vertel("load",n,"","locl",1,"","retr","var",1)
endprgm
sub()
pause "Valeur : "&string(var)
L'appel de Vertel charge la valeur de "n", entrée dans le sous-programme,
dans la liste de retour de Vertel (voir fonction "load"). Le dossier local actif est modifié
avec "locl", il s'agit à présent du dossier local 1 rang en arrière, c'est à dire celui du
programme principal et non plus de "sub()". L'utilisation de "retr" retourne donc la valeur
chargée dans la variable locale "var" du programme principal, qui n'a plus qu'à l'afficher.
• Fonctions texte
prty :: "expr", x, y [, mode]
Affiche l'expression mathematique "expression" aux
coordonnées x,y et en mode Pretty Print (le style utilisé dans l'écran HOME). Attention, même
si "expr" est une chaine, elle n'en reste pas moins une expression mathématique, par exemple
"2x/5".
Les modes sont 0 pour afficher normalement ("OR" logique), 1 pour écraser le fond, 2 pour
afficher en négatif, 3 pour inverser ("OU" exclusif), 4 pour afficher en "ET" logique, et 5
pour affiché en pointillés (comme les menus désactivés d'AMS).
Si le mode vaut -1, au lieu d'afficher l'expression, la fonction retourne ses dimentions en
largeur et hauteur.
stxt :: "texte"
Inscrit le texte "texte" dans la status line (la barre
située en bas, contenant le dossier actif, les modes, etc...). Ce texte sera forcément écrit
en petite police et aligné à gauche.
text :: "texte", x, y, taille, mode
Inscrit le texte "texte" sur l'écran, aux coordonnées x,y.
Il est possible d'utiliser les 3 tailles de police disponibles sur la Ti, à savoir 0 pour la
petite police, 1 pour la moyenne, et 2 pour la grande.
Les modes possibles sont 0 pour afficher normalement, 1 pour écraser le fond, 2 pour afficher
en négatif, 3 pour inverser, et 4 pour afficher en pointillés.
wdth :: "texte", taille
Retourne la largeur en pixels du texte "texte" avec la
police de taille "taille". Il faut savoir que si les largeurs des lettres en police moyenne et
grande sont fixes (respectivement 6 et 8 pixels), ce n'est pas le cas pour la petite police.
Pour aligner correctement du texte il est donc pratique d'utiliser cette fonction qui indique
exactement la largeur du texte à inscrire.
Les hauteurs des caractères de taille 0, 1 et 2 sont respectivement 6, 8 et 10 pixels.
• Fonctions de variables
delt :: "var", type
Supprime la variable "var" de la calculatrice si le type
est à 0, ou le dossier "var" (ainsi que son contenu) si le type est à 1. L'interet de cette
fonction est que la variable sera supprimée même si elle est cachée, verrouillée ou archivée.
glue :: "group" [, "var"]
Permet de regrouper plusieurs fichiers en un seul, de type
"VTG". Ce fichier pourra être extrait pour récupérer son contenu.
Si "var" est donnée, le groupe "group" est créé si il n'existait pas et "var" est ajoutée à
l'interieur. Ainsi, vous pouvez appeller vertel("glue","group",{"var1","var2","var3"...}) pour
ajouter plusieurs fichiers dans un groupe.
Si "var" n'est pas indiquée, la fonction extrait tous les fichiers contenus dans le groupe sur
la Ti. Si vous aviez groupé les fichiers en indiquant un nom de dossier (par exemple
vertel("glue","group","main\var")), Vertel essaiera de les placer dans ce dossier au lieu de
les extraire dans le dossier courant. Si ce dossier n'existe pas, il sera demandé à
l'utilisateur de le créer.
hide :: "var", type, mode
Permet de cacher ou non une variable "var" (si le type
vaut 0) ou un dossier "var" (si le type vaut 1). Si le mode vaut 1 la variable sera cachée,
si il vaut 0 elle sera rendue visible. Une variable cachée n'apparait plus dans l'écran
Vars-Link d'AMS.
list :: [ "folder" ], mode, [ filter ]
Cette fonction permet d'obtenir une liste des fichiers ou
dossiers de la Ti. Si l'argument "folder" n'est pas donné, la fonction retourne la liste de
tous les dossiers. En revanche si "folder" est le nom d'un dossier, elle retourne la liste des
fichiers qu'il contient.
L'argument "mode" sert alors, si il est fixé à 1, à retourner tous
les noms de fichier préfixés du nom du dossier et de "\" (par exemple un fichier nommé "prog"
dans le dossier "main" sera retourné "prog" si le mode vaut 0, ou "main\prog" si le mode vaut
1).
Le filtre, facultatif, sert à filtrer les fichiers que doit retourner la fonction. Si il n'est
pas donné, elle retournera tous les fichiers sans exeption; si il est fixé elle ne retournera
que les fichiers de type correspondant (voir "Types de fichiers" pour plus d'informations).
Si le filtre vaut par exemple 45, ce qui correspond aux variables de type "STR", la fonction
ne retournera alors que les variables "STR" dans le dossier indiqué.
load :: { "str" / num }
La fonction "load", seule, n'a pas beaucoup d'interet.
Elle sert à charger une valeur (chaine ou nombre) dans la liste de retour de Vertel,
récupérable donc avec la fonction "retr". Ceci peut servir à completer des résultats d'autres
fonctions, mais a surtout d'autres utilités comme celle de pouvoir, en combinaison avec la
fonction "locl", transmettre des variables locales d'un sous-programme à ses lanceurs (voir
la fonction "locl").
make :: "var", size [, mode] [, "data"]
Crée une variable "var" de taille "size" sur la Ti. Cette
fonction peut se réveler très utile en connaissant la structure des variables.
Le mode, si il est à 1, empeche la fonction de remettre à zéro tous les octets de la variable.
Il faut savoir que si "make" est utilisé sur une variable déjà existante, elle ne sera pas
supprimée mais redimentionnée, le mode à 1 permet donc de conserver en partie son contenu.
Le dernier argument, optionnel, sert à définir immédiatement des données dans
la variable créée. Ces données commencent juste après les octets de taille, il s'agit donc
uniquement du contenu de la variable. La valeur de chaque octet doit être représentée par le
caractère correspondant (par exemple la valeur 49 est représenté char(49), c'est à dire "1"),
et vous pouvez utiliser les valeurs qui posent problème (0, 2 et 13) avec "\0", "\2" et "\r"
(attention il s'agit bien d'un anti-slash et non pas un "/"). Le caractère "\" est considéré
comme caractère d'échappement précedant un caractère spécial. Pour l'utiliser en temps que "vrai"
caractère "\" (pour représenter la valeur ord("\") = 92), il faut utiliser "\\".
Dernière chose, la séquence "\*NC" sert à répeter N fois le caractère C : si
il est présent un grand nombre de fois à la suite, cette technique économise de la place
(attention, le caractère sera répeté ord(N) fois : \*2a ne répete pas la valeur 97 (ord("a") =
97) 2 fois, mais ord("2") = 50 fois !).
Voici par exemple comment créer une variable de type NUM contenant "123" et
une autre de type STR contenant "aaabbbbbbbbbccc" sur la calculatrice :
vertel("make",{"nombre","chaine"},{5,20},{"{~€","\0aaa\*»bccc\0-"})
(Remplacer "€" par le char(31), "~" par le char(1) et "»" par le char(9))
read :: "var", byte, length
Retourne "length" octets de la variable "var", en partant
de l'octet "byte". Ainsi si byte vaut 0 et length vaut 4, la fonction retournera 4 octets en
partant du n°0, c'est à dire du premier (le premier octet est 0, le dernier size-1 si size est
la taille de la variable).
Si length vaut 0, la fonction lit "var" jusqu'à son dernier octet, vertel("read","var") permet
donc de lire une variable entièrement.
Attention, il n'existe aucune restriction en cas de lecture "en-dehors" de la variable
(au-delà de sa taille). Il sera alors impossible de savoir à quoi correspondent les octets
retournés.
sequ :: init, step, count
Renvoie dans la liste de retour une suite de valeurs
numeriques, dont la première vaut "init", la seconde "init+step", la troisième "init+step*2",
la quatrième "init+step*3", et ainsi de suite.
L'interet de cette fonction est de génerer une liste de valeurs plus rapidement qu'avec la
fonction "seq" du Ti-Basic, et de l'utilise ensuite en argument pour une autre fonctions.
vertel("sequ",0,3,10)
Cet appel charge dans la liste de retour 10 valeurs :
{0,3,6,9,12,15,18,21,24,27,30}
size :: "var"
Retourne la taille en octets de la variable "var". Il est
également possible de connaitre cette taille avec la fonction "read" : la taille de la
variable est égale à "256 * b0 + b1 + 2" si b0 est l'octet n°0 et b1 le n°1.
C'est donc pour une simple raison de praticité que la fonction "size" est disponible.
stat :: "var", type
Retourne l'état du dossier "var" ou de la variable "var"
sous forme de 2 ou 3 bits. Pour rappel, savoir si le premier bit de la variable "bit" est armé
ou non s'effectue avec le test "if (bit and 1)>0", pour le deuxième "if (bit and 2)>0" et pour
le troisième "if (bit and 4)>0".
Si type vaut 0, la fonction considère que "var" est une variable. Le premier bit est alors
armé si la variable est cachée, le deuxième si elle est archivée, et le troisième si elle est
verrouillée.
Si type vaut 1, la fonction considère que "var" est un dossier. Le premier bit est alors armé
si le dossier est caché, le second si il est fermé (dans le Vars-Link).
strn :: num
Converti un nombre en chaine, comme le ferait la fonction
"string()" à quelques différences près : Vertel n'accepte que les nombres entiers comprits
entre -2147483648 et 2147483647, cette fonction ne réactive pas le break (voir fonction "brek"),
et surtout la gestion des listes permet de convertir une longue liste de nombres en une liste
de chaine en un instant (effectuer string({1,2,3}) retourne "{1,2,3}" et non pas {"1","2","3"}
comme permet de le faire Vertel).
test :: { "str" / num }, { "str" / num } [, mode]
La fonction "test" permet de comparer deux nombres ou
chaines, elle ne retourne rien si ils sont différents, et retourne un nombre si ils sont
identiques. Ce nombre est en fait incrémenté à chaque cycle dans le cas de liste, ce qui
permet par exemple de rechercher rapidement si une valeur appartient à une liste :
local r
{"aaa","bbb","ccc","aaa","bbb","ccc"}->list
vertel("test","#list","bbb","","retr","r")
if dim(r)=0 then
text "bbb n'est pas dans la liste"
else
text "bbb trouvé au(x) rang(s) : "&string(r)
endif
Cet exemple affichera "bbb trouvé au(x) rang(s) : {2,5}", car la fonction
a retourné ces deux rangs en trouvant deux fois la chaine recherchée dans la liste.
Le mode, si il vaut 0 (par défaut), teste l'égalité entre les deux valeurs. Dans le cas d'une comparaison
de nombres, il est possible de le mettre à 1 pour tester si le premier nombre est inferieur
au deuxième, à 2 pour tester si le deuxième est inferieur au premier, ou à 3 pour tester si le premier est différent du deuxième. Dans le cas d'une
comparaison de chaines, le fait de mettre le mode à une valeur N supperieure à 0 a pour effet
de ne comparer que les N premiers caractères de chaque chaine.
type :: "var" [, mode]
Retourne le type de la variable "var" comme l'aurait fait
la fonction "getType()" à quelques différences près : Elle permet de retourner le type d'une
grande liste de fichiers grâce à la gestion de listes, peut connaitre le type réel des fichiers
"OTH", et retourne toujours le type en anglais, même si la calculatrice est dans une autre
langue.
Si le mode est à 1, Vertel renverra seulement "OTH" pour les variables de type personalisé,
comme le fait getType(), sinon elle indiquera la véritable extension.
Les types existants sont : "NONE", "STR", "MAT", "LIST", "PRGM", "FUNC", "DATA", "GDB", "PIC",
"TEXT", "ASM", "OTH" et "EXPR".
Pour conserver la compatibilité avec getType(), la fonction renvoie "NONE" si la variable
n'existe pas.
writ :: "var", byte, value
Permet d'écrire un octet dans une variable. L'octet n°byte
de la variable "var" sera donc écrasé et remplacé par "value".
Pour simplifier l'écriture d'une série d'octets en utilisant la gestion de listes, la variable
value est auto-incrémentée. Il est donc inutile d'écrire
vertel("writ","var",{2,3,4,5},{0,97,0,45}) pour inscrire 4 valeurs aux octets n°2, 3, 4 et 5,
vertel("writ","var",2,{0,97,0,45}) aura le même effet.
Une sécurité empêche d'écrire au-dela de la variable.
Vertyos