Developpez.com

Télécharger gratuitement le magazine des développeurs, le bimestriel des développeurs avec une sélection des meilleurs tutoriels

Developpez.com - Autres
X

Choisissez d'abord la catégorieensuite la rubrique :


Initiation au Kid's Programming Langage

Date de publication : 08/12/2006

Par Xavier VLIEGHE (autres articles)
 

Cet article vous propose une initiation au Kid's Programming Langage, un langage tout récent se proposant d'apprendre les bases de la programmation aux enfants ainsi qu'aux débutants.

               Version PDF   Version hors-ligne

À qui est destiné ce tutoriel (et comment le compléter)
Quelques rappels et compléments
I.1. Le célèbre "Hello World"
I.1.1. La Structure du Programme
I.1.2. Les Commentaires
I.1.3. Les Procédures
I.1.4. Les Variables
I.1.5. L'Appel d'une Procédure avec Argument
I.1.6. Quelques compléments
a. Les fonctions
b. Les variables "avancées"
c. Les constantes
d. Les structures de boucle
e. Indentation et sauts de lignes
Manuel
II.1. Toutes les procédures pour dessiner au Crayon
II.2. Toutes les procédures/fonctions pour piloter la Console
II.3. Toutes les fonctions/procédures de gestion du Clavier / Boîtes de dialogue
II.4. Toutes les procédures/fonctions de gestion de l'Écran
II.5. Toutes les fonctions/procédures de gestion des Sprites
II.6. Toutes les fonctions de manipulation des Données
II.7. Toutes les fonctions mathématiques
II.8. Une procédure pour faire du bruit
II.9. Les procédures de Trace
Annexe : La liste des couleurs


À qui est destiné ce tutoriel (et comment le compléter)


Ce tutoriel est destiné aux personnes qui ont apprécié l' fr Introduction à la programmation avec KPL et qui ont envie d'aller un peu plus loin avec KPL. Si vous ne connaissez pas KPL, je ne saurais trop vous conseiller la lecture de cette introduction, qui est en fait une initiation au langage KPL et aux concepts basiques de la programmation, avant de poursuivre la lecture de cet article.

L'installation de KPL est bien entendu très fortement conseillé, ce tutoriel se basant entre autres sur des programmes fournis avec ce langage.

Faute de temps, je n'y ai pas mis tout ce que je voulais y mettre, donc ce document est susceptible d'évoluer au fil du temps. Si vous souhaitez contribuer, vous pouvez m'envoyer :



Quelques rappels et compléments

Nous allons d'abord rappeler quelques concepts fondamentaux à l'aide d'un petit programme, déjà écrit et présent dans le répertoire Learning Programs, LearningProgram001a.kpl

Comme vous l'avez peut-être constaté, KPL fournit en effet un certain nombre de programmes qu'il est bien entendu conseillé d'étudier avant de se lancer dans l'écriture de vos propres programmes.

A noter que chaque programme est présent en double dans cette liste : les programmes dont le nom se terminent par un "a" sont identiques à leur quasi-homonyme sans le "a", à la différence qu'ils ont été expurgés de tous commentaires.


I.1. Le célèbre "Hello World"

Hé oui, on commence tous par dire "Bonjour" en programmation ! KPL ne déroge donc pas à la règle en nous proposant un petit programme simple, dans lequel nous allons pouvoir étudier les concepts fondamentaux suivants :

Commençons par l'ouvrir :

Figure 01 : Ouverture de notre programme

I.1.1. La Structure du Programme

Concernant la structure, la première chose à savoir est est qu'un programme KPL commence toujours par l'instruction Program, suivie du nom du programme, et qu'elle se termine par l'instruction End Program :

Program HelloWord
    ...
End Program
                

Entre ces 2 instructions, on trouveras dans notre programme 3 procédures (Method).
Nous allons d'abord nous intéresser à celle nommée Main(). En effet, c'est la procédure principale du programme (d'où son nom), c'est celle qui est appelée à chaque démarrage du programme.
La présence de cette procédure est donc obligatoire pour l'exécution du programme !

Voici le contenu de la procédure Main() de notre exemple :

Method Main()

    Color ( Blue )
		
    SayHello()

    Var WhatIWantToSay As String
    
    WhatIWantToSay = "Hello Again!"
    SaySomething(WhatIWantToSay)

    WhatIWantToSay = "Goodbye!"
    SaySomething(WhatIWantToSay)

End Method
               

Nous allons expliquer dans les paragraphes suivants ce qui signifie ce code, après un petit laïus sur les commentaires :


I.1.2. Les Commentaires

Un commentaire est un texte qui n'est pas une instruction destinée à être interprétée par l'ordinateur, ces mots sont ignorés de celui-ci quand le programme est lancé. Le rôle principal d'un commentaire est de donner des explications sur le code. Un texte (ou une portion de code) est en commentaire si :

Comme illustré ci-dessous, il est facile de reconnaître les commentaires : ils sont en vert !

Figure 02 : Quelques exemples de mise en forme de Commentaires

Il est possible de commenter un programme que vous écrivez, directement au sein du code. Ceci est très intéressant pour les raisons suivantes :

Ces 2 avantages peuvent paraître assez abstraits pour un débutant en programmation, mais il ne faut pas oublier que si aujourd'hui, vous n'en êtes qu'au stade de l'apprentissage de la programmation, vous serez peut-être ammenés plus tard à en faire votre métier. Ces 2 bonnes raisons se justifieront alors pleinement, et les bonnes habitudes prises lors de vos début vous demanderont vraiment peu d'efforts supplémentaires.

Il peut également être pratique de mettre en commentaire une ou plusieurs lignes de code, en phase de conception d'un programme, pour désactiver spécifiquement une partie du code par exemple.


I.1.3. Les Procédures

Revenons à notre procédure Main(), et commençons à décortiquer son contenu. Ignorons l'instruction Color (Blue), que vous connaissez peut-être déjà (et que nous retrouverons de toutes façons au I.1.5), et intéressons-nous à la ligne suivante :
appel de la procédure :

    SayHello()
                
Cette instruction est un appel de la procédure SayHello(), comme nous en avons déjà rencontrés dans les programmes précédemment étudiés (Print, MoveTo, LoadSprite, etc.). Ce qu'il est intéressant de noter à propos de cette procédure est que celle-ci est définie directement dans notre programme :
définition de la procédure

Method SayHello()
    // écrit le texte "Hello!" à l'écran lors de l'exécution du programme
    PrintLine ("Hello!")
End Method
                
Elle n'est pas très consistante, mais elle a le mérite d'introduire un point important : vous pouvez définir vos propres procédures lorsque vous écrivez vos programmes !

La question qui en découle naturellement est la suivante : "Pourquoi faire ?"

La réponse est la suivante : organiser votre code à l'aide de procédure vous permet de mieux structurer votre programme. De plus, à partir du moment où une portion de code apparaît au moins 2 fois dans un programme, vous devez vous posez la question de savoir si il ne serait pas mieux de centraliser ce code via une procédure, et d'appeler cette procédure lorsque cela est requis.

Quand vous serez un peu plus à l'aise avec la syntxe de KPL, prenez le temps de découvrir quelques uns des programmes fournis avec KPL, leurs auteurs les ont très bien structurés, leur lecture devrait donc vous fournir tous les exemples nécéssaires pour illustrer ce point.


I.1.4. Les Variables

Dans chacun des programmes que vous écrirez, vous pourrez utiliser des variables. Pour faire simple, nous dirons qu'une variable est une petite case de votre ordinateur, à laquelle vous donner un nom. Vous pouvez demander à chaque variable de se rappeler d'une information, un nombre ou un texte par exemple. Les variables doivent être créées (on dit "déclarées") dans un programme avant de pouvoir être utilisées. Ceci se fait grâce au mot clé Define (Anciennement Var avec KPL 1.0).
Déclaration d'une variable (LearningProgramm001.kpl)

Define WhatIWantToSay As String  // (signifie "ce que je veux dire")    
                

Étudions cet exemple de création de quelques variables, utiles pour saisir des informations sur une personne :
Déclaration de plusieurs variables

Define Nom    As String  // variable de type chaîne de caractères
Define Prenom As String  // idem ...
Define Age    As Int     // Integer = nombre entier
                
Les noms et prénoms se gèrent à l'aide d'une variable de type String, qui sert à stocker du texte : cela peut être un simple mot, une phrase complète, en bref, tout ce que vous pouvez rentrer au clavier !

Une variable de type Int vous permettra de gérer des nombres (entiers) comme l'age.

Il existe d'autres types de variables qu'il est préférable de connaître dès maintenant :
- Les variables de type Decimal permettent la gestion des nombres décimaux,
- les variables de type Bool permettent la gestions des booléens.
Un booléen peut prendre uniquement 2 valeurs, Vrai (True) ou Faux (False).

Il existe d'autres notions plus complexes, comme les tableau ou les structures, que nous aborderons bientôt.

warning Attention à choisir des noms explicites pour vos variables, ceci est fort utile pour la lecture et la compréhension du programme !
L'instruction consistant à stocker une information dans une variable s'appelle l'affectation.
Cette instruction est réalisée grâce au signe égal "=".
Affectation

// LearningProgramm001.kpl :
// première affectation :
WhatIWantToSay = "Hello Again!"

// seconde affectation :
WhatIWantToSay = "Goodbye!"


// affectation de valaurs définissant une personne :
Nom = "Dubois"
Prenom = "Gaëtan"
Age = 12
                
Vous aurez noté que les textes, ou chaînes de caractères, sont encadrées par des guillemets, mais pas les nombres. Attention, une variable déclarée et dans laquelle aucune affectation n'a été faite ne contient rien. Il est possible d'initialiser une variable dès sa déclaration de la manière suivante :
Initialisation

Dim Nom As String = "Dubois"
                
Cela revient à déclarer la variable et à lui affecter une valeur dans la même instruction.

Une notion importante à connaître à propos des variable est leur portée.

En effet, une variable peut être déclarée dans la procédure Main (), ou dans une une autre procédure :
Dans le premier cas, une variable sera connue dès sa déclaration, dans tout le programme.
Dans le second cas, la portée de la variable sera restreinte à la procédure, ce qui signifie que si vous tentez d'y faire appel à l'extérieur de cette procédure, vous déclencherez une erreur !


I.1.5. L'Appel d'une Procédure avec Argument

Les procédures, qu'elles aient été définies par vos soins ou qu'elles fassent déjà partie du langage (on parle alors de bibliothèque) peuvent être désignées pour accomplir un traitement dépendant de certaines données variables.


...                
Color ( Blue )               
...
                
Ici, le programme appelle une procédure du langage KPL qui permet de changer la couleur d'écriture du crayon (donc des messages ou dessins qui apparaîtront sur l'écran du programme). Un argument est nécessaire lors de cet appel : le nom de la couleur. Ici, le développeur a choisi la couleur bleue.

Vous imaginez sans peine que si une procédure est destinée à dessiner un carré, il faut lui donner toutes les informations nécessaires lui permettant de savoir où dessiner ce carré, quelles seront ses dimensions, etc.
Voici un exemple d'une telle procédure :

Method DessineCarre (X1 As Int, X2 As Int, Y1 As Int, Y2 As Int)
// Cette procédure dessine un carré dont les côté sont parallèles au bords de l'écran
// X1 et X2 sont les coordonnées sur l'axe des abcisses,
// Y1 et Y2 sont les coordonnées sur l'axe des ordonnées.

    // On teste la validite des paramètres : 
    // (Abs est la fonction qui renvoie une valeur absolue) du paramètre qui lui est passé)
    If X1 <> X2 And Y1 <> Y2 And Abs(X1 - X2) = Abs(Y1 - Y2) Then
        Pen (False)
        MoveTo (X1, Y1)
        Pen (True)

        // On trace nos 4 côtés :
        MoveTo (X2, Y1)
        MoveTo (X2, Y2)
        MoveTo (X1, Y2)
        MoveTo (X1, Y1)
    Else
        // Renvoie un message d'erreur :
        Alert ("Ces coordonnnées ne définissent pas un carré !", "Erreur")
    End If

End Method 
                
Vous pouvez à loisir compléter cette procédure en lui passant en 5° paramètre la couleur dans laquelle doit être dessiné le carré, en 6° paramètre le largeur du crayon, etc.
Pour la tester ensuite, rien de plus simple, appelez-la :

Program DessineMoiUnCarre

    Method DessineCarre (X1 As Int, X2 As Int, Y1 As Int, Y2 As Int)
        .... (cf le contenu ci-dessus)
    End Method

    Method Main()
        DessineCarre (5, 15, 20, 30) // Dessine un petit carré
        DessineCarre (5, 15, 20, 35) // Renvoie un message d'erreur !
    End Method

End Program                
                
À completer ? ...


I.1.6. Quelques compléments


a. Les fonctions

Une fonction est assez analogue à une procédure : elle peut contenir un certain nombre d'instructions et donc effectuer un traitement particulier. Elle se différencie des procédure pour la raison suivante : une fonction peut retourner une valeur, pour diverses raisons :
- pouvoir indiquer au programme si le traitement s'est correctement terminé ou non,
- donner le résultat d'un calcul dont elle avait la charge,
- etc.

Voici des exemples simples de fonctions :

Function Addition (NbrA As Int, NbrB As Int) As Int
    Define Somme As Int
    Somme = Nbra + Nbrb

    Return Somme
End Function

Function AireDuCercle (Rayon As Decimal) As Decimal
    Define Pi As Decimal
    Pi = 3.141592

    Return Pi * Power(Rayon, 2) 
    // Power permet d'élever un nombre à la puissance spécifiée en tant que 2° argument
    // Power (Rayon, 2) = Rayon * Rayon = Rayon "au carré"
End Function
                    
Le retour de la valeur se fait grâce à l'instruction Return.


b. Les variables "avancées"

Outre les différents types de variables déjà abordés précédemment (String, Int, Decimal, Bool), il est intéressant de savoir qu'il existe des manières plus "complexes" de gérer les données d'un programme. ce qui vous permettant d'aborder des programmes plus intéressants, variables que vous croiserez inévitablement si vous étudiez les programmes fournis en exemple avec KPL.

Le premier type, assez répandu, est le tableau :
Un tableau est caractérisé par un type, et par le nombre de ses éléments.
Il sert à stocker des information de même type, et souvent de même nature. Ex :

// si l'on souhaite gérer les températures de la journée :
Define Temperature As Int [24]

Temperature [0] = 12 // à minuit
Temperature [1] = 12 // à 01h00
...
Temperature [12] = 19 // à midi
...
                    
KPL V1.1 ne permet pas la gestion de tableaux multi-dimensionnel, KPL V2 comblera cette lacune.

Le second type est la structure.
Une structure est un type de variable lui-même composé de plusieurs variables, qui vous permettent de gére un ensemble d'informations, souvent rattachées à une même entité.

Par exemple, si l'on gère un jeu avec des petits personages, on aura besoin de connaître à tout moment du jeu :
- sa position (X et Y),
- sa direction (par exemple : 1=Nord, 2=Ouest, 3=Sud, 4=Est),
- son nom ,
- etc.

Ex :

// Définition de la structure                    
Structure Bonhomme
   iPosX As Int
   iPosX As Int
   iDir  As Int
   sNom As String
End Structure

// Utilisation de la structure pour gérer un bonhomme :
Define Personnage1 As Bonhomme

Personnage1.iPosX = 150 
Personnage1.iPosY = 250
Personnage1.iDir = 2
Personnage1.sNom = "Jean"
                    
To Complete : ANY ...


c. Les constantes

Il est intéressant de connaître ce concept simple, bien que KPL ne gère pas les constantes à proprement parler. En effet, il est possible d'utiliser cette notion dans vos programme. Une constante se comporte comme une variable initialisée dès sa déclaration, mais elle n'est pas destinée à être modifiée en cours de programme !
Quel peut donc donc leur usage ?

Utiliser des constantes avec des noms bien choisis permet de rendre un programme plus clair et lisible,
En cas de changement de valeur d'une constante, vous n'aurez qu'une seule ligne à modifier : l'initialisation de la constante. Cela vous permet donc d'éviter de modifier toutes les lignes dans lesquelles vous avez utilisé sa valeur.

La déclaration d'une constante se fait de la manière suivante :

Define NombreBalles As Int = 75
Define NombreAvions As Int = 10
Define Pi As Decimal = 3.14159
                    
Si vous utilisez des constantes, ce sera donc à vous de bien faire attention à ne pas les modifier, le programme les considérant comme des variables simples. Vous trouverez en annexe la liste des constantes que KPL utilise pour recenser les couleurs. Par exemple, Blue est une constante de type Int (entier), de valeur 10. Pour le vérifier, il vous suffit de remplacer "Color (Blue)" par "Color (10)" dans notre programme. Vous admettrez sans peine je pense que la première instruction est plus parlante que la seconde, surtout si vous avez quelques notions d'anglais.


d. Les structures de boucle

Les boucles sont utiles pour répéter des instructions semblables ou similaires, elles permettent de réaliser ces opérations à "peu de frais" plutôt que de coder X fois la même instruction.

La boucle la plus simple qui soit consiste à répeter la même instruction un nombre donné de fois. Elle utilise le mot-clé Loop, en voici un exemple :
     
// boucle Loop simple :
Loop 3
   PrintLine ("Test Loop")
End Loop                            
                    
Ce petit programme écrira 3 fois la même chose, "Test Loop". Facile d'utilisation, mais pas très impressionant ...

Il est également possible de boucler sur des instructions analogues, mais en faisant varier l'indice, à l'aide de For. Si vous avez lu fr le premier tutoriel consacré à KPL, vous avez du apercevoir un tel exemple :
     
// boucle For : 
For ufoY = 0 To 150
   Delay (10) // attend 10 ms
   MoveSpriteToPoint( "UFO", 50, ufoY )
Next                          
                    
Cette boucle est déjà plus intéressante, car elle permet de gérer une variable.

Il est également possible de boucler sur le compteur en l'incrémentant non pas de 1 à chaque boucle, mais d'une valeur choisie, spécifiée grâce au mot-clé Step :
     
// boucle For avec Step: 
For ufoY = 0 To 150 Step 10
   Delay (10) // attend 10 ms
   MoveSpriteToPoint( "UFO", 50, ufoY )
Next                               
                    
Enfin, le dernier type de boucle à connaître est la boucle "Tant que". Contrairement aux autres, le nombre d'itération n'est pas fixé à l'avance, et peut dépendre d'une variable ou d'une action de l'utilisateur du programme.

Testez le code suivant :
    
Define Nbr As Decimal = 1.1

While Nbr < 2
   Nbr = Nbr * 1.1
   PrintLine ("Nbr = " + Nbr)

End While         			
                    
On part d'un nombre qui vaut 1,1 (n'oubliez pas que le séparateur décimal est le point, et ce dans la plupartd es langages de programmation), et on le multiplie par 1,1, jusqu'à ce qu'on dépasse 2. Saviez-vous combien de fois il fallait boucler pour obtenir ce résultat avant d'essayer ce petit bout de programme ?
Si oui, vous êtes calé en math ;)


e. Indentation et sauts de lignes

L'indentation est une norme d'écriture universelle, qui consiste à commencer à écrire en justifiant à gauche (en général les instructions définissant la structure du programme), et à mettre en retrait le code à l'intérieur. Le nombre d'espace servant à l'indentation peut être fixé à 2, 3 ou 4 espaces, il est également possible d'utiliser la tabulation dans certains éditeurs de code.

De même, sauter des lignes entre certains "blocs" du programme permet d'améliorer la clarté et la lisibilité du programme.

Ces conseils peuvent peut-être paraître naturels, reprenons la procédure DessineCarre et voyons ce que cela donne si on ne les applique pas :
Procédure sans commentaires, saut de ligne ni indentation
 
Method DessineCarre (X1 As Int, X2 As Int, Y1 As Int, Y2 As Int)
If X1 <> X2 And Y1 <> Y2 And Abs(X1 - X2) = Abs(Y1 - Y2) Then
Pen (False)
MoveTo (X1, Y1)
Pen (True)
MoveTo (X2, Y1)
MoveTo (X2, Y2)
MoveTo (X1, Y2)
MoveTo (X1, Y1)
Else
Alert ("Ces coordonnnées ne définissent pas un carré !", "Erreur")
End If
End Method            
                 
Au premier coup d'oeil, impossible de deviner ce que fait cette procédure, les structures ne sont pas mises en valeur, bref c'est illisible ! Bien qu'un programme soit lu et interprêté par un ordinateur, il est écrit (donc maintenu et corrigé) par des humains, et sa lisibilité est donc essentielle ! Écrivez des programmes clairs et lisibles, vous prendrez plus de plaisir à programmer ;)


Manuel


II.1. Toutes les procédures pour dessiner au Crayon

Ces procédures sont destinées à tracer des dessins simples à l'écran. Elles sont simples à utiliser et permettent de donner un résultat graphique rapide, ce qui permet d'aborder la programmation avec les plus jeunes via quelques programmes courts et basiques.

Lorsque vous donner des instructions à l'ordinateur via un programme de dessin KPL, l'ordinateur mémorisera plusieurs informations après chacune de vos instructions :
- la position du crayon, définie par un couple de coordonnées (X,Y),
- la couleur du crayon,
- le fait que le crayon soit activé/désactivé.

warning Si la notion de coordonnées définies par un couple de valeurs (X,Y) ne vous dit rien, merci de vous reporter au tutoriel d'initiation au langage KPL, plus précisément au chapitre fr Et graphiquement, ça donne quoi ?!.

Dans l'écriture d'un tel programme, il est important de tenir compte de ces valeurs implicites, car elles seront souvent utiles pour que l'instruction suivante fonctionne correctement.
Souvenez-vous, ceci est illustré dans le premier tutoriel KPL, quand vous avez programmé le dessin d'une étoile :
- la couleur était spécifiée en début de programme, et s'appliquait donc à toutes les instructions suivantes,
- le traçage d'un trait grâce à la procédure MoveTo démarrait à chaque fois du dernier point (X, Y) atteint.

Par la suite, nous qualifierons ces valeurs d'actuelles ou en cours pour y faire référence.

La liste des procédures est la suivante :

Procédure Circle ( Diameter AS INT, Filled AS BOOL ) :
Permet de dessiner un cercle dont le centre est l'emplacement actuel du crayon, du diamètre spécifié en premier argument et dont la couleur est celle en cours. Le paramètre Filled (rempli) permet de colorier ou pas le cercle avec la même couleur.

Procédure Color ( Color AS INT ) :
Permet de choisir la couleur du crayon, selon le paramètre spécifié. Il est possible d'utiliser une valeur numérique, ou une constante correspondant à une couleur, dont vous trouverez la liste en annexe (en anglais).
Exemple : Color ( Blue ) or Color ( 10 )

Procédure ColorRGB ( Red AS INT, Blue AS INT, Green AS INT ) :
Permet de choisir la couleur du crayon, en combinant les intensités des 3 couleurs primaires rouge, verte et bleue. Par exemple, ColorRGB ( 0, 0, 0 ) donne du noir, et ColorRGB ( 255, 255, 255 ) donne du blanc.

Fonction DrawLine ( StartX AS INT, StartY AS INT) to (EndX AS INT, EndY AS INT) :
Trace un trait du point défini par les coordonnées (StartX, StartY) jusqu'au point (EndX, EndY), dont la couleur est celle du crayon.

Procédure Ellipse ( Width AS INT, Height AS INT, Filled AS BOOL ) :
Dessine une ellipse à l'écran dont le centre est l'emplacement actuel du crayon, et la couleur est celle du crayon. Le paramètre Filled permet de colorier ou pas le cercle.

Procédure MoveBy ( DeltaX AS INT, DeltaY AS INT ) :
Déplace en ligne droite le crayon en fonction des valeurs passées en paramètres : le point d'arrivée est défini par les coordonnées du point de départ auxquelles on ajoute les valeurs passées en paramètre.

Procédure MoveTo ( X AS INT, Y AS INT ) :
À partir de la position en cours, déplace en ligne droite le crayon jusqu'au point défini par les coordonnées passées en paramètre.

Procédure Pen (IsPenDown AS BOOL) :
Permet d'activer ou désactiver (reboucher) le crayon en fonction de la valeur du paramètre : si le crayon est désactivé, il ne tracera pas de ligne quand on le déplace.

Procédure PenWidth ( PenWidth AS INT ) :
Permet de spécifier la largeur du crayon (en pixel).

Procédure PutPixel ( X AS DECIMAL, Y AS DECIMAL ) :
Colore un pixel (un point) à l'écran a l'endroit spécifié, dans la couleur actuelle.

Procédure Rectangle ( Width AS INT, Height AS INT, Filled AS BOOL ) :
Dessine un rectangle avec la couleur en cours, à partir de la position en cours et dont les dimensions sont définies via les paramètres. Si le paramètre Filled est à true (vrai), le rectangle sera plein (colorié).


II.2. Toutes les procédures/fonctions pour piloter la Console

La console est l'outil qui permettra au programmeur de réaliser un programme interactif :
- la console permet de poser des questions, et de récupérer les réponses dans des variables utilisables dans le programmes,
- la console permet d'afficher des messages sur l'écran KPL.

Vous trouverez parfois de petits exemples de codes suite à l'explication d'une procédure ou d'une fonction, permettant d'illustrer l'applications de celles-ci. Ces bouts de codes peuvent être de 2 natures différentes :
- ce sont soit des programmes "entiers" qu'il vous suffit de copier/coller dans un nouveau programme vierge de KPL pour les exécuter, et ainsi tester les fonctionnalités qui vous sont exposées. Vous les reconnaîtrez grâce à leur structure (Program, Methode Main ...),
- ce sont soit des appels isolés de la procédure/fonction dont il est question, que vous pourrez insérer dans d'autres programmes complet afin d'en tester les effets. Vous les identifierez facilement puisque ces exemples de codes seront précédés et suivis de 3 petits points.

La liste des procédures est la suivante :

Procédure ConsoleWrite ( Message As STRING ) :
Cette procédure permet d'écrire un message dans la console. Le texte à écrire est spécifié dans l'argument nommé Message.
La procédure ConsoleWrite écrit le texte dans la console, et conserve le curseur (la petite barre verticale clignotante) en fin de ligne.
Un autre appel de cette procédure continuera donc d'écrire à la suite de la ligne précédemment commencée.
Voici un exemple d'utilisation de cette procédure :
Exemple d'utilisation de ConsoleWrite

Program ConsoleWrite
    Method Main()
        ShowConsole () //Affiche la console
        ConsoleWrite ("Ce programme ")
        ConsoleWrite ("écrit dans ")
        ConsoleWrite ("la console")
    End Method
End Program
            
Procédure ConsoleWriteLine ( Message As STRING ) :
Cette procédure est analogue à la précédente, à une différence près : après avoir écrit dans la console, le curseur se positionnera au début de la ligne suivante : ceci est utile pour aérer le texte à écrire si besoin. Voici un exemple d'utilisation de cette procédure :
Exemple d'utilisation de ConsoleWriteLine

Program ConsoleWriteLine
    Method Main()
        ShowConsole () //Affiche la console
        ConsoleWriteLine ("Ceci est un Titre")
        ConsoleWriteLine ("") //Saut de ligne sans texte
        ConsoleWriteLine ("Ceci est du texte,")
        ConsoleWriteLine ("Ceci est du texte.")
    End Method
End Program
            
Procédure ClearConsole () :
Très utile pour le ménage, cette procédure nettoie la console de tous ses messages. Bien entendu, une application immédiate de cette procédure après avoir affiché du texte n'est pas une bonne idée, car l'utilisateur n'aura pas le temps de le lire : on attend en général qu'il valide la lecture en pressant une toche par exemple :
Exemple d'utilisation de ClearConsole

Program ClearConsole
    Method Main()
        ShowConsole () //Affiche la console
		
        ConsoleWriteLine( "Appuyez sur un bouton pour effacer ce texte :" )
        ConsoleReadKey( False ) //Le programme s'arrête et attend que l'utilisateur press une touche ...
		
        ClearConsole ()
    End Method
End Program            
            
Procédure HideConsole () :
Une fois le dialogue terminé, permet de cacher la console et rebascule donc en mode graphique.

Procédure MaximizeConsole () :
Suite à l'appel de cette procédure, la console utilisera tout l'espace de la fenêtre du programme KPL.

Procédure SetConsoleBackgroundColor ( Color As INT) :
Permet de définir la couleur de fond de la console. De même que pour la procédure Color (et comme pour toutes les procédures acceptant un argument nommé Color), cette procédure accepte en argument une valeur numérique, ou une constante correspondant à une couleur, dont vous trouverez la liste en annexe (en anglais).
Exemple d'utilisation de SetConsoleBackgroundColor

...
Set SetConsoleBackgroundColor (Red) // Fond rouge
...
            
Procédure SetConsoleBulletMode ( IsBulletModeOn As BOOL ) :
Cette procédure, si elle est appelée avec une valeur d'argument à True, vous permet ensuite d'écrire du texte sous forme de liste à puces. L'appel suivant de cette procédure avec un argument dont la valeur est False rebasculera l'écriture en mode normal. Voici un exemple d'utilisation :
Exemple d'utilisation de SetConsoleBulletMode

Program SetConsoleBulletMode
    Method Main()
        ShowConsole () //Affiche la console
		
        ConsoleWriteLine( "Affichage d'une liste d'animaux familiers :" )
		
        SetConsoleBulletMode( True ) //Passe en mode liste à puce :
		
        ConsoleWriteLine( "Chat")
        ConsoleWriteLine( "Chien")
        ConsoleWriteLine( "Poisson")
		
        SetConsoleBulletMode( False ) //Repasse en mode normal :
		
        ConsoleWriteLine( "C'est tout ...")
		
    End Method
End Program        
            
Procédure SetConsoleFont ( Name As STRING, Size As INT ) :
Permet de spécifier la police d'écriture, ainsi que sa taille, très utile pour mettre certains messages du programme en valeur. Afin de connaître les noms de polices disponible, il vous suffit d'en consulter la liste via votre éditeur de texte favori. La taille de la police doit quant à elle être entre 8 et 72.
Exemple d'utilisation de SetConsoleFont

Program SetConsoleFont
    Method Main()
        ShowConsole () //Affiche la console
		
        ConsoleWriteLine( "Affichage d'une liste d'animaux familiers :" )
		
        SetConsoleFont( "Arial", 15 ) //écrit en Arial, taille 15 :
		
        ConsoleWriteLine( "Chat")
        ConsoleWriteLine( "Chien")
        ConsoleWriteLine( "Poisson")
		
        SetConsoleFont( "Times New Roman", 10 ) //écrit en TMR, taille 10 :
		
        ConsoleWriteLine( "C'est tout ...")
		
    End Method
End Program               
            
Procédure SetConsoleFontColor ( Color As INT ) :
Permet de changer la taille de la police utilisée.

Procédure SetConsoleFontSize ( Size As DECIMAL ) :
Permet de choisir la couleur dans laquelle vous écrirez vos messages.

Procédure SetConsoleFontStyle ( Bold As BOOL, Italic As BOOL, Underline As BOOL ) :
Permet de définir le style de la police, la signification des 3 paramètres de type booléen (vrai ou faux) étant la suivante :

- Bold permet d'indiquer si vous écrivez en Gras,
- Italic permet d'écrire en Italique,
- UnderLine permet de souligner votre texte.

Procédure SetConsoleHangingIndent ( Indent As INT ) :
Permet de définir le décalage, au sein d'un paragraph, entre le bord gauche de la première ligne de texte et les lignes suivantes du paragraphe. Utile pour de la mise en page, seulement si votre programme a de long discours à faire lire à l'utilisateur.

Procédure SetConsoleHeight ( Height As INT ) :
La console pouvant être utilisée en même temps qu'un affichage graphique, cette procédure permet de spécifier une taille en pixels, pour la console. La console est toujours située dans la partie basse de l'écran de KPL.

Procédure SetConsoleIndent ( Indent As INT) :
Définit l'indentation (le décalage par rapport au bord de l'écran), en pixels, du texte écrit dans la console. Si mon explication n'est pas assez claire, exécutez l'exemple ci-dessus :

Program SetConsoleIndent
    Method Main()
        ShowConsole () // Affiche la console
		
        ConsoleWriteLine( "Affichage d'une liste d'animaux familiers :" )
		
        SetConsoleFontColor (Red)
		
        SetConsoleIndent (5) // on décale de 5 pixels
        ConsoleWriteLine( "Hamster")
		
        SetConsoleIndent (10) // on décale de 10 pixels
        ConsoleWriteLine( "Canari")
		
        SetConsoleIndent (15) // on décale de 15 pixels
        ConsoleWriteLine( "Perruche")

    End Method
End Program        
            
Procédure SetConsoleTextAlignment ( Alignment As STRING ) :
Vous pouvez définir de quelle manière vous allez "justifier" votre texte, en fonction du paramètre passé :
- "Left" : à gauche,
- "Center" : centré,
- "Right" : à droite,
Si vous n'êtes pas un habitué du traitement de texte, et comme un petit exemple vaut mieux qu'un long discours, voici un exemple :

Program SetConsoleTextAlignment
    Method Main()
        ShowConsole () // Affiche la console
		
        SetConsoleFont( "Arial", 12 )
		
        //Le texte est justifié à gauche par défaut :
        ConsoleWriteLine( "Voici un texte justifié à gauche," )
        ConsoleWriteLine( "" )
		
        SetConsoleTextAlignment( "Center" )
        ConsoleWriteLine( "ce texte-ci est centré," )
        ConsoleWriteLine( "" )
		
        SetConsoleTextAlignment( "Right" )
        ConsoleWriteLine( "et celui-ci est justifié à droite !" )
        
        ConsoleWriteLine( "" )
				
    End Method
End Program              
            
Procédure ShowConsole ()
Cette procédure étant utilisée dans tous les exemples ci-dessus, vous l'aurez sans doute compris : cette procédure sert à faire apparaître la console, qui n'est par défaut pas active.


La liste des fonctions est la suivante :

Fonction ConsoleReadDecimal ( Prompt As String, EchoToConsole As Bool ) As DECIMAL :
Vous pouvez utiliser cette fonction pour récupérer un nombre décimal saisi par l'utilisateur.
Quand elle est appelée, cette fonction fait apparaître une zone de saisie au bas de la console, où l'utilisateur rentrera sa valeur. La validation se fait par la touche Entrée ou le bouton Submit.
- Le paramètre Prompt est un message affiché à côté de la zone de saisie, qui sert en général à préciser à l'utilisateur ce qu'on attend de lui.
- Le paramètre EchoToConsole indique au programme, si sa valeur est à TRUE, de ré-afficher le Prompt et la valeur entrée par l'utilisateur.

Fonction ConsoleReadInt ( Prompt As String, EchoToConsole As Bool ) As INT :
Vous pouvez utiliser cette fonction pour récupérer un nombre entier saisi par l'utilisateur.
Quand elle est appelée, cette fonction fait apparaître une zone de saisie au bas de la console, où l'utilisateur rentrera sa valeur. La validation se fait par la touche Entrée ou le bouton Submit.
- Le paramètre Prompt est un message affiché à côté de la zone de saisie, qui sert en général à préciser à l'utilisateur ce qu'on attend de lui.
- Le paramètre EchoToConsole indique au programme, si sa valeur est à TRUE, de ré-afficher le Prompt et la valeur entrée par l'utilisateur.

Fonction ConsoleReadKey ( EchoToConsole As Bool ) As STRING :
À compléter ...

Fonction ConsoleReadLine ( Prompt As String, EchoToConsole As Bool ) As STRING :
Vous pouvez utiliser cette fonction pour récupérer du texte (une chaîne de caractère) saisi par l'utilisateur.
Quand elle est appelée, cette fonction fait apparaître une zone de saisie au bas de la console, où l'utilisateur rentrera sa valeur. La validation se fait par la touche Entrée ou le bouton Submit.
- Le paramètre Prompt est un message affiché à côté de la zone de saisie, qui sert en général à préciser à l'utilisateur ce qu'on attend de lui.
- Le paramètre EchoToConsole indique au programme, si sa valeur est à TRUE, de ré-afficher le Prompt et la valeur entrée par l'utilisateur.



II.3. Toutes les fonctions/procédures de gestion du Clavier / Boîtes de dialogue

Les fonctions/procédures suivantes servent à :

La liste des fonctions est la suivante :

Fonction Confirm ( Message As STRING, Title As STRING ) AS BOOL :
Fait apparaître une boîte de dialogue dont le message est la variable passée en premier paramètre, et dont le titre est la variable passée en second paramètre. L'exécution du programme est alors stoppée, et l'utilisateur doit alors cliquer sur OUI (la fonction renverra True) ou NON (la fonction renverra False).
Cette procédure sert à poser une question à l'utilisateur.
Exemple d'utilisation de Confirm

	Method Main()

		Define Reponse As Bool
		Define Message As String
		Define Titre   As String
		
		Message = "Voulez-vous exécuter ce programme ?"
		Titre = "Mon Programme"
		Reponse = Confirm (Message, Titre)
		
		If Reponse = True Then
			// ici le code du programme ...
		Else
			// Rien ...
		End If

	End Method
Fonction GetKey ( ) AS STRING :
Cette fonction renvoie la valeur de la dernière touche pressée par l'utilisateur, ou bien une chaîne vide si aucune touche n'a été pressée pendant l'exécutionb du programme.

Fonction IsKeyDown ( Key AS STRING ) AS BOOL :
Renvoie True si la touche passée en argument est pressée par l'utilisateur. Par exemple, IsKeyDown( "Right" ) va renvoyer True si l'utilisateur presse la touche flêche droite.

Procédure Alert ( Message As STRING, Title As STRING) :
À l'instar de la fonction Confirm, cette procédure affiche une boîte de dialogue avec un message et un titre, et stoppe l'exécution du programme. Mais seul un bouton OK est disponible, que l'utilisateur doit cliquer pour que le programme continue.
Cette procédure sert à afficher un message informatif ou d'avertissement à l'utilisateur.


II.4. Toutes les procédures/fonctions de gestion de l'Écran

À compléter ...


II.5. Toutes les fonctions/procédures de gestion des Sprites

Vous trouverez ici tout ce qu'il vous faut pour manipuler les fameux "sprites", çàd les fichiers images servant dans les programmes KPL. Certaines sprites sont composés de différentes "frames", çad de différents petits dessins qu'il est possible de faire défiler pour donner une impression de mouvememnt. Vous pouvez récupérer des fichiers images (au formats gif, png, jpg), sur Internet ou de toute autre source, pour les inclure dans vos programmes, il vous suffit de copier ou d'enregistrer ces fichiers sous le répertoire "C:\Program Files\Morrison Schwartz\Kids Programming Language\Media\Images" si votre installation a été faite sous le chemin standard (sinon, vous devrez être capable de retrouver vous même le chemin choisi).


II.6. Toutes les fonctions de manipulation des Données

Les fonctions suivantes ont pour but la manipulation de texte, afin de le mettre en forme ou d'en extraire des données.

Fonction ArrayLength ( List AS Array ) AS INT :
Renvoie la taille du tableau List.

Fonction ConvertToBool ( Value AS ANY) AS BOOL :
Convertit le paramètre value en booléen, quel que soit sont type d'origine.
Pour une valeur numérique, 0 sera convertit en False, alors que toute autre valeur sera True.
Attention, pour une chaîne de caractère différente de "True" ou "False", le programme renverra une erreur !

Fonction ConvertToDecimal ( Value AS ANY) AS Decimal :
Convertit le paramètre Value en DECIMAL.
Attention aux erreurs de conversions, le programme vous renverra une erreur en cas de conversion impossible !

Fonction ConvertToInt ( Value AS ANY) AS INT :
Convertit le paramètre Value en INT.
Attention aux erreurs de conversions, le programme vous renverra une erreur en cas de conversion impossible !

Fonction ConvertToString ( Value AS ANY) AS STRING :
Convertit le paramètre Value en STRING.

Fonction FormatString ( FormatString AS STRING, Value AS ANY ) AS STRING :
???

Fonction IndexOf ( Value AS STRING, Pattern AS STRING ) AS INT :
Renvoie la position de la première occurrence de la chaîne Pattern trouvée dans la chaîne Value.
Voici un exemple :

Method Main()
	Define pos As Int
	
	pos = IndexOf ("abcdef", "a")
	PrintLine ("pos = " + pos) // Renvoie 1
	
	pos = IndexOf ("abcdef", "cd")
	PrintLine ("pos = " + pos) // Renvoie 3
		
	pos = IndexOf ("abcdef", "az")
	PrintLine ("pos = " + pos) // Renvoie 0, aucune occurence de "az" trouvée dans "abcdef" ...
End Method
            
Fonction ParseInt ( Value AS INT ) AS INT :
Méthode obsolète en V1.1, à ne plus utiliser !

Fonction Split ( Text AS STRING, Separateur AS STRING ) AS ARRAY :
Découpe la chaîne Text en un tableau de chaîne : la scission se fait à chaque occurrence de la chaîne separateur.

Fonction StringLength ( Text AS STRING ) AS INT :
Renvoie la longueur de la chaîne de catactères Text.

Fonction StringReplace (Text AS STRING, Pattern AS STRING, NewPattern AS STRING ) AS STRING :
Remplace dans Text toutes les occurrences de Pattern par NewPattern

Fonction Substring ( Text AS STRING, StartPos AS INT, Length AS INT ) AS STRING :
Renvoie une portion de la chaîne Text : cette portion démarre de la position StartPos, avec un maximum de Length lettres.
Attention, la fonction est buggée dans KPL V1.1, utilisez plutôt la foncttion MonSubstring (à inclure à vos programmes) :

Function MonSubString (sChaine As String, iDeb As Int, iLng As Int) As String
// sChaine : variable à découper
// iDeb    : position de départ
// iLng    : longueur 
	
	Define iLgChaine As Int    // Longueur de l'argument "chaine"
	Define i         As Int    // Indice de boucle
	Define sResult   As String // Résultat
		
	iLgChaine = StringLength(sChaine)
	
	/* On rajoute unespace car Substring ne fonctionne pas sur la dernière position d'une chaine
	   Ex : Substring ("test", 4, 1) = "" !!!*/ 
	sChaine = sChaine + " "
	
	sResult = ""
	
	If iDeb > iLgChaine Then
		/* Si la position de début est > à la longueur de la chaîne, 
		   on retourne une chaîne vide */
		Return sResult
	End If
	
	If iLng <= 0 Then
		/* Si la longueur requise est inférieur ou égale à 0
		   on retourne une chaîne vide */
		Return sResult
	End If
	
	For i = 1 To iLgChaine
		If i >= iDeb Then
			// On ajoute les caractères 1 par 1
			sResult = sResult + Substring (sChaine, i, 1)
			
			// Si on atteint la longueur requise, on renvoie sResult
			If StringLength(sResult) = iLng Then
				Return sResult
			End If
		End If
	Next
	
	/* Si on sort de la boucle sans avoir atteint la longueur souhaitée, 
	   on retourne sResult */
	Return (sResult)
	
End Function
            
Fonction ToLower ( Value AS STRING ) AS STRING :
Convertit la chaîne Value en remplaçant toutes les majuscules en minuscule.

Fonction ToUpper ( Value AS STRING ) AS STRING :
Contrairement à la précédente, convertit la chaîne Value en remplaçant les minuscules en majuscules.

Voici un exemple de fonction afin de formatter un nom en mettant en majuscule la première lettre, et les autres en minuscules :

Function FormatNom (leNom AS STRING) AS STRING

    Define LongueurNom AS INT    // La longueur du nom
    Define Initiale    AS STRING // La première lettre du nom
    Define ResteDuNom  AS STRING // Le reste ...
    
    LongueurNom = StringLength(leNom)
    
    If LongueurNom = 0 Then
        Return ""
    Else
        Initiale = ToUpper(MonSubstring (leNom, 1, 1))
        ResteDuNom = ToLower(MonSubString (leNom, 2, LongueurNom - 1))
        
        Return Initiale + ResteDuNom
    End If
    
End Function
            

II.7. Toutes les fonctions mathématiques

En programmation, quel que soit le langage, attention au séparateur décimal : c'est le point !
Par contre, il n'y a pas de séparateur de millier à spécifier lors de l'écriture de vos programme.
Quant aux angles, ils sont exprimés en degrés.

Introduction à compléter ...

Fonction Abs ( Value AS INT ) AS INT :
Renvoie la valeur absolue du nombre Value. Abs est l'abréviation de "absolute value", qui se traduit par "valeur absolue".

Fonction Acos ( d AS Decimal ) AS Decimal :
Renvoie l'arccosinus ou le cosinus inverse (donc l'angle) en degrés de d (entre -1 et 1). La valeur renvoyée est comprise entre 0° et 180°.

Fonction ArcTan ( d AS Decimal ) AS Decimal:
Renvoie l'arctangente en degrés (donc l'angle) dont la tangente est d. La valeur renvoyée est comprise entre -90° et 90°.

Fonction ArcTan2 ( X AS Decimal, Y as Decimal ) AS Decimal :
Renvoie l'arctangente en degrés (donc l'angle) issues des coordonnées (X, Y). Cette fonction renvoie l'angle formé par la droite, qui passe par le point (X, Y) et par l'origine (0;0) et l'axe des abscisses (axe des x). La valeur renvoyée est donc comprise entre -180° et 180°.

Fonction Asin ( d AS Decimal ) AS Decimal :
Renvoie l'arcsinus ou le sinus inverse (donc l'angle) en degrés de d (entre -1 et 1). La valeur renvoyée est comprise entre -90° et 90°.

Fonction Ceiling ( Value AS Decimal ) AS Decimal :
Renvoie le plus petit entier supérieur ou égal à Value. Ceiling se traduit par "plafond".

Fonction Cos ( d AS DECIMAL ) AS DECIMAL :
Renvoie le cosinus de l'angle d (en degrés).

Fonction CosH ( d AS DECIMAL ) AS DECIMAL :
Renvoie le cosinus hyperbolique de l'angle d passé en paramètre.

Fonction Exp ( d AS DECIMAL ) AS DECIMAL :
Renvoie l'exponentielle de d, ou e à la puissance d. e vaut à peut près 2,71828183.

Fonction Floor ( Value AS Decimal ) AS Decimal :
Renvoie le plus grand nombre entier inférieur ou égal à d.
Floor se traduit par "plancher".

Fonction Log ( d AS DECIMAL ) AS DECIMAL :
Renvoie le logarithme naturel (base e) de d.

Fonction Log10 ( d AS DECIMAL ) AS DECIMAL :
Renvoie le logarithme décimal (de base 10) de d.

Fonction LogBase ( value AS DECIMAL, base AS DECIMAL ) AS DECIMAL :
Renvoie le logarithme du nombre value en base base.

Fonction Max ( ValueA AS Any, ValueB AS Any ) AS Any :
Renvoie le plus grand des 2 nombres passés en paramètres, ValueA ou ValueB.

Fonction Min ( ValueA AS Any, ValueB AS Any ) AS Any :
Renvoie le plus petit des 2 nombres passés en paramètres, ValueA ou ValueB.

Fonction Power ( value AS DECIMAL, power AS DECIMAL ) AS DECIMAL :
Renvoie la valeur du nombre value élevé à la puissance power.

Fonction Random ( Mini AS INT, Maxi AS INT ) AS DECIMAL :
Renvoie un nombre entier pris au hasard entre Mini et Maxi inclus. Par exemple, Random ( 1, 10 ) renverra un entier entre 1 et 10.

Fonction Round ( d AS Decimal ) AS DECIMAL :
Renvoie l'entier le plus proche de d. Si d est un demi-entier, alors l'arrondi se fera à l'entier supérieur.

Fonction RoundToPlace ( d AS Decimal, decimalPlaces AS Decimal ) AS DECIMAL :
Arrondir un nombre décimal d à decimalPlaces décimales.

Fonction Sin ( d AS DECIMAL ) DECIMAL :
Renvoie le sinus de l'angle d.

Fonction Sqrt ( Value AS DECIMAL ) AS DECIMAL :
Renvoie la racine carrée de Value.
Sqrt est l'abréviation de "square root", qui se traduit par ... "racine carrée".

Fonction Tan ( d AS DECIMAL ) AS DECIMAL :
Renvoie la tangeant de l'angle d.

Fonction TanH ( d AS DECIMAL ) AS DECIMAL :
Renvoie la tangeante hyperboloqie de d.

Fonction TickCount ( ) AS DECIMAL :
Renvoie le nombre de secondes passées depuis que le programme KPL est démarré. Cette fonction peut servir comme chronomètre.



II.8. Une procédure pour faire du bruit

Une seule procédure existe pour jouer les fichiers WAV livrés avec KPL :

Procédure PlaySound ( FileName AS STRING ) :
Joue le fichier son dont le nom est passé en paramétre (s'il est présent dans le répertoire Sons).


II.9. Les procédures de Trace

À compléter ...


Annexe : La liste des couleurs

Voici la liste des couleurs disponibles dans KPL :

Transparent = 0 AliceBlue = 1 AntiqueWhite = 2
Aqua = 3 Aquamarine = 4 Azure = 5
Beige = 6 Bisque = 7 Black = 8
BlanchedAlmond = 9 Blue = 10 BlueViolet = 11
Brown = 12 BurlyWood = 13 CadetBlue = 14
Chartreuse = 15 Chocolate = 16 Coral = 17
CornflowerBlue = 18 Cornsilk = 19 Crimson = 20
Cyan = 21 DarkBlue = 22 DarkCyan = 23
DarkGoldenrod = 24 DarkGray = 25 DarkGreen = 26
DarkKhaki = 27 DarkMagenta = 28 DarkOliveGreen = 29
DarkOrange = 30 DarkOrchid = 31 DarkRed = 32
DarkSalmon = 33 DarkSeaGreen = 34 DarkSlateBlue = 35
DarkSlateGray = 36 DarkTurquoise = 37 DarkViolet = 38
DeepPink = 39 DeepSkyBlue = 40 DimGray = 41
DodgerBlue = 42 Firebrick = 43 FloralWhite = 44
ForestGreen = 45 Fuchsia = 46 Gainsboro = 47
GhostWhite = 48 Gold = 49 Goldenrod = 50
Gray = 51 Green = 52 GreenYellow = 53
Honeydew = 54 HotPink = 55 IndianRed = 56
Indigo = 57 Ivory = 58 Khaki = 59
Lavender = 60 LavenderBlush = 61 LawnGreen = 62
LemonChiffon = 63 LightBlue = 64 LightCoral = 65
LightCyan = 66 LightGoldenrodYellow = 67 LightGreen = 68
LightGray = 69 LightPink = 70 LightSalmon = 71
LightSeaGreen = 72 LightSkyBlue = 73 LightSlateGray = 74
LightSteelBlue = 75 LightYellow = 76 Lime = 77
LimeGreen = 78 Linen = 79 Magenta = 80
Maroon = 81 MediumAquamarine = 82 MediumBlue = 83
MediumOrchid = 84 MediumPurple = 85 MediumSeaGreen = 86
MediumSlateBlue = 87 MediumSpringGreen = 88 MediumTurquoise = 89
MediumVioletRed = 90 MidnightBlue = 91 MintCream = 92
MistyRose = 93 Moccasin = 94 NavajoWhite = 95
Navy = 96 OldLace = 97 Olive = 98
OliveDrab = 99 Orange = 100 OrangeRed = 101
Orchid = 102 PaleGoldenrod = 103 PaleGreen = 104
PaleTurquoise = 105 PaleVioletRed = 106 PapayaWhip = 107
PeachPuff = 108 Peru = 109 Pink = 110
Plum = 111 PowderBlue = 112 Purple = 113
Red = 114 RosyBrown = 115 RoyalBlue = 116
SaddleBrown = 117 Salmon = 118 SandyBrown = 119
SeaGreen = 120 SeaShell = 121 Sienna = 122
Silver = 123 SkyBlue = 124 SlateBlue = 125
SlateGray = 126 Snow = 127 SpringGreen = 128
SteelBlue = 129 Tan = 130 Teal = 131
Thistle = 132 Tomato = 133 Turquoise = 134
Violet = 135 Wheat = 136 White = 137
WhiteSmoke = 138 Yellow = 139 YellowGreen = 140


               Version PDF   Version hors-ligne

Valid XHTML 1.1!Valid CSS!

Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur. La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à l'obtention préalable de l'autorisation de l'auteur.
Contacter le responsable de la rubrique Autres