Vertel



.\ 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.



Retour au sommaire

Vertyos