JISNTools Howto - ISN Breizh Le codage au collège et au lycée

JISN Tools Howto
Version 0.3
JISNTools est un package regroupant un ensemble de classes Java permettant de travailler sur
les images, le texte, le réseau, des grilles de jeux...
Les FrameWorks
Les framesWork sont des classes proposant des fonctions permettant d'afficher différents
types de données (images, texte, grilles de jeux,...) dans une fenêtre.
Les classes d'objets spécifiques ISN
Il s'agit d'objets permettant d'aborder le codage numériques en ISN. Vous disposez du type
Image, webcam, socket, txt...
Installation d'ISNTools sous Eclipse
Il suffit une fois Eclipse lancé, de choisir menu/import/Existing Project into Workspace
puis de lui indiqué le nom de l'archive JISNTools.zip (capture 1 ci-dessous)
Pour mettre à jour JISNTools, il suffit de supprimer le projet JISNTools (Click droit/ Delete)
puis d'installer la nouvelle version.
Pour utiliser JISNTools dans un nouveau projet, il suffit une fois que le projet est créé de lui
indiqué le chemin vers JISNTools - Click droit sur le nom du projet et choisir Build Path/
Configure Build Path (Capture 2 ci-dessous).
( Capture 1 )
( Capture 2 )
Si vous utilisez la webcam il vous faudra également rajouter la librairie webcamLib
FrameWorkImage
(pour plus de possibilités voir la javadoc associée sous Eclipse)
Classe permettant d'afficher des images dans une fenêtre. Pour pouvoir utiliser cette classe
vous devez l'instanciée (créer un objet de ce type) en ajoutant les lignes de déclaration et de
création suivantes au début de votre programme :
FrameWorkImage fwimg;
fwimg = new FrameWorkImage("Titre de la fenêtre");
Ensuite vous disposez de différentes méthodes pour afficher des images :
fwimg.showImage(img1);
// affiche l'image img1 (type Image)
fwimg.showImage(img1,img2,img3,img4,200,200);
// affiche 4 images en 200x200
fwimg.showImage(img1,img2,img3,null,200,200);
// affiche 3 images en 200x200
fwimg.showImage(timg, 200, 200, 5, true);
//
//
//
//
affiche les images contenues dans
le tableau d'image timg[] en 200x200
5 images par lignes. Un click sur une
image l'affiche en taille réelle (true)
fwimg.showZoomImage(img1,10,true);
// affiche l'image img1 avec un zoom de 10
// et une grille (rouge)
Exemple de programme utilisant FrameWorkImage :
import jisn.tools.*;
// On indique ici que l'on utilise la librairie ISNTools
public class AffichageImage {
static FrameWorkImage;
static Image img1;
public static void main(String[] args){
fwimg = new FrameWorkImage("Affichage Image");
img1 = new Image("D:/Images/paysage.png");
fwimg.showImage(img1);
fwimg.showZoomImage(img1,10,true);
} // End Main
} // End Class
// On affiche l'image
// On affiche l'image avec un facteur de zoom de 10
// et une grille délimitant chaque pixel.
Image
(pour plus de possibilités voir la javadoc associée sous Eclipse)
Classe permettant de travailler sur des images. Pour pouvoir utiliser cette classe vous devez
l'instanciée (créer un objet de ce type) en ajoutant les lignes de déclaration et de création
suivantes au début de votre programme :
Image img = new Image("D:/MesImages/tux.png");
// On charge une image
Image img = new Image(500, 500);
// On créé une image de 500x500
// de couleur blanche par défaut
Image img = new Image(500,500,Color.red);
// On créé une image de 500x500
// de couleur rouge
Image img = new Image(XXXX.class.getResource("images/tux.png"));
// charge l'image tux.png du répertoire ressource
images de la classe XXXX dans Eclipse.
Ensuite vous disposez de différentes méthodes pour travailler sur ces images :
img.getPixelColor(x,y);
img.setPixelColor(x,y,color);
img.setPixelColor(x,y,r,g,b);
// Renvoie la couleur du pixel (type Color)
// Spécifie la nouvelle couleur du pixel (type Color)
// Spécifie la nouvelle couleur du pixel (type int)
img.clear();
img.resize(100,100);
// Efface l'image (fond blanc)
// Redimensionne l'image en 100x100
img.getWidth();
img.getHeight();
// Renvoie la largeur de l'image (type int)
// Renvoie la hauteur de l'image (type int)
img.saveToURL(filename);
// Sauvegarde l'image (type string)
Exemple de programme utilisant le type Image :
import jisn.tools.*;
import java.awt.Color;
// Ligne à ajouter pour utiliser le type Color
public class test {
static FrameWorkImage fwimg;
static Image img1;
public static void main(String[] args)
{
fwimg = new FrameWorkImage("Composantes Image");
img1 = new Image(test.class.getResource("images/tux.png"));
for(int x =0; x < img1.getWidth() ; x++)
for (int y=0; y < img1.getHeight(); y++)
System.out.println(img1.getPixelColor(x,y));
fwimg.showImage(img1);
}// End main
}// End Class
// on affiche l'image
// On affiche la couleur
// de chaque pixel
MacroImage
(pour plus de possibilités voir la javadoc associée sous Eclipse)
Classe permettant de travailler sur des Macro images, images composée de Macro pixels
(PIXEL), correspondant à des pixels de grande taille. Pour pouvoir utiliser cette classe vous
devez l'instanciée (créer un objet de ce type) en ajoutant les lignes de déclaration et de
création suivantes au début de votre programme :
// Création d'une image de 20x20 MacroPixels (PIXEL) de taille 30x30
// la valeur true indique que l'on affiche une grille pour mieux distinguer les PIXELS
MacroImage img = new MacroImage(20,20,30,true);
Ensuite vous disposez de différentes méthodes pour travailler sur ces images :
img.getPIXELColor(x,y);
img.setPIXELColor(x,y,color);
// Renvoie la couleur du pixel (type Color)
// Spécifie la nouvelle couleur du pixel (type Color)
img.clear();
img.drawGrid()
// Efface l'image (fond blanc)
// Affiche la grille
img.getGridWidth();
img.getGridHeight();
// Renvoie la largeur de la grille de PIXELS (type int)
// Renvoie la hauteur de la grille de PIXELS (type int)
img.saveToURL(filename);
// Sauvegarde l'image (type string)
Exemple de programme utilisant le type Image :
import java.awt.Color;
import java.util.Random;
import jisn.tools.*;
public class RandomMacroImage {
static FrameWorkImage fwimg;
static MacroImage img1;
public static void main(String[] args)
{
fwimg = new FrameWorkImage("Pixel Line Finder");
// Création d'une image de 20 x 20 MacroPIXELS de taille 30x30 avec grille
MacroImage img1 = new MacroImage(20,20,30,true);
// Création d'un générateur de nombres aléatoires
Random r = new Random();
// Placement aléatoire de PIXELS noirs sur l'image
for (int i = 0 ; i < 30 ;i++)
img1.setPIXELColor(r.nextInt(img1.getGridWidth()),
r.nextInt(img1.getGridHeight()),
Color.green);
fwimg.showImage(img1);
}// End main
}// End Class
Color
(pour plus de possibilités voir la javadoc associée sur le site Oracle)
Classe Java permettant de travailler sur les couleurs des pixels d'une image. Pour l'utiliser vous
devez rajouter en début de programme la ligne : import java.awt.Color;
Color c = new Color(100);
// Créé la couleur de la valeur spécifiée (type int).
Color c = new Color(100,120,215); // Créé la couleur à partir des composantes RGB
// indiquées (type int).
Color.black;
Color.red;
// Constante définissant la couleur Noire.
// Constante définissant la couleur rouge.
Ensuite vous disposez de différentes méthodes pour travailler sur les couleurs :
c.getRed();
c.getGreen();
c.getBlue();
c.getAlpha();
c.getRGB();
//
//
//
//
//
Renvoie
Renvoie
Renvoie
Renvoie
Renvoie
la
la
la
la
la
composante
composante
composante
composante
valeur RGB
rouge
verte
bleue
alpha
(type
de cette couleur.
de cette couleur.
de cette couleur.
de cette couleur.
int) de cette couleur.
Exemple de programme utilisant le type Color :
import jisn.tools.*;
import java.awt.Color;
public class test {
static FrameWorkImage;
static Image img1;
public static void main(String[] args)
{
fwimg = new FrameWorkImage("Composantes Image");
img1 = new Image("D:/Images/paysage.png");
Color pixelColor;
for(int x =0; x < img1.getWidth() ; x++)
for (int y=0; y < img1.getHeight(); y++){
pixelColor =img1.getPixelColor(x,y);
System.out.println(pixelColor.getAlpha()); // On affiche la composante alpha
// de chaque pixel
}
fwimg.showImage(img1);
}// End main
}// End Class
// on affiche l'image
Webam
(pour plus d'infos voir la javadoc associée sur Eclipse et sur
https://github.com/sarxos/webcam-capture )
Classe permettant de capturer des images via une webcamPour pouvoir utiliser cette classe vous
devrez ajouter les lignes suivantes au début de votre programme :
import com.github.sarxos.webcam.Webcam;
// A rajouter dans la zone import du programme
Webcam.setAutoOpenMode(true); // mode d'utilisation standard, gère automatiquement
// l'ouverture de a Webcam
Ensuite vous pouvez récupérer les images capturées dans une image de type isn.tools.Image :
Image img1 = new Image(Webcam.getDefault().getImage()); //capture image dans img1
remarque : A l'execution d'un programme webcam vous aurez le message d'avertissement suivant :
Not enough args for boolean OpenIMAJGrabber.startSession(int, int, double) → ne pas en tenir compte
Exemple 1 (capture de 2 images et affichage avec FrameWorkImage) :
import jisn.tools.*;
import com.github.sarxos.webcam.Webcam;
public class webcam1 {
static FrameWorkImage fwimg = new FrameWorkImage("webcam capture : 2 images");
public static void main(String[] args) throws InterruptedException {
Webcam.setAutoOpenMode(true);
// automatically open if webcam is closed
Thread.sleep(1000); // wait 1 second
Image img1 = new Image(Webcam.getDefault().getImage()); //capture img1
Thread.sleep(500); // wait 1/2 second
Image img2 = new Image(Webcam.getDefault().getImage()); //capture img2
fwimg.showImage(img1,img2,null,null,200,200);
}//End class main
}// End class webcam1
Exemple 2 (capture de 10 images et affichage avec FrameWorkImage) :
import isn.tools.*;
import com.github.sarxos.webcam.Webcam;
public class webcam2 {
static FrameWorkImage fwimg = new FrameWorkImage("webcam capture : tableau images");
public static void main(String[] args) throws InterruptedException {
Image timg[] = new Image[10];
Webcam.setAutoOpenMode(true);
// automatically open if webcam is closed
for (int i=0; i < 10 ; i++){
Thread.sleep(500);
timg[i] = new Image(Webcam.getDefault().getImage());
System.out.println("Attention pour la photo n° "+i);
Thread.sleep(5);
}// End for i
fwimg.showImage(timg, 200, 200, 5, true);
}// End main
}// End class webcam2
FrameWorkDialog
(pour plus de possibilités voir la javadoc associée sous Eclipse)
Classe permettant d'afficher une fenêtre de dialogue pour récupérer une réponse de
l'utilisateur (texte ou nombre). Pour pouvoir utiliser cette classe vous devez l'instanciée (créer
un objet de ce type) en ajoutant les lignes de déclaration et de création suivantes au début de
votre programme :
FrameWorkDialog fwdiag = new FrameWorkDialog("Titre de la fenêtre");
Ensuite vous disposez de différents types de dialogues possibles :
String s = fwdiag.askForString("Votre dialogue");
Integer age = fwdiag.askForInteger("Votre dialogue");
float prix = fwdiag.askForFloat("Votre dialogue");
Affichera une fenêtre comme ci-dessous :
Pour changer le titre des fenêtres : fwdiag.setTitle("Titre de la fenêtre");
char reponse = fwdiag.askForYesNo("Votre dialogue");
Affichera une fenêtre comme ci-dessous :
(Retourne la valeur 'Y' ou 'N')
Exemple de programme utilisant FrameWorkDialog :
import jisn.tools.*;
public class userDialog {
static FrameWorkDialog fwdiag = new FrameWorkDialog();
public static void main(String[] args) {
String name = fwdiag.askForString("Votre Nom ? ","Conversation");
System.out.println("votre nom : "+name);
}// End Main
} // End Class
FrameWorkTxtCode
(pour plus de possibilités voir la javadoc associée sous Eclipse)
Classe permettant d'afficher du texte dans une fenêtre. Pour pouvoir utiliser cette classe vous
devez l'instanciée (créer un objet de ce type) en ajoutant les lignes de déclaration et de
création suivantes au début de votre programme :
FrameWorkTxtCode fwtxt = new FrameWorkTxtCode("Titre de la fenêtre");
Ensuite vous disposez de différentes méthodes pour afficher du texte :
fwtxt.affiche(s);
fwtxt.affiche(c);
fwtxt.affiche(n);
// affiche la chaîne de caractère s (type String)
// affiche le caractère c (type char)
// affiche la valeur entière n (type int)
fwtxt.afficheCodeAuFormatHex(c);
fwtxt.afficheCodeAuFormatDec(c);
fwtxt.afficheCodeAuFormatBin(c);
fwtxt.afficheCodeAuFormatCar(c);
fwtxt.sautDeLigne();
fwtxt.resetConsole();
//
//
//
//
affiche
affiche
affiche
affiche
la
la
la
le
valeur
valeur
valeur
glyphe
héxadécimal
décimal
binaire
c (type int)
// Passe à la ligne suivante.
// Efface la zone de texte de la fenêtre
fwtxt.stringDump(s);
fwtxt.fileDump(filename);
// affiche un dump de la chaîne s (type String)
// affiche un dump du fichier spécifié (type String)
Exemple de programme utilisant FrameWorkTxtCode :
import jisn.tools.*;
public class fileDump {
static FrameWorkTxtCode fwtxt;
static TxtFileReader txtFileR;
public static void main(String[] args)
{
fwtxt = new FrameWorkTxtCode("FileDump");
txtFileR = new TxtFileReader();
txtFileR.open("D:/MesTextes/avare.txt");
int c = txtFileR.readNextByteCode();
while (c != -1) {
fwtxt. afficheCodeAuFormatHex(c);
fwtxt.affiche("--");
c = txtFileR.readNextByteCode();
}
fwtxt.sautDeLigne();
fwtxt.fileDump("D:/MesTextes/avare.txt");
} // End Main
} // End Class
c (type int) en
c (type int) en
c (type int) en
correspondant à
TxtFileReader/TxtFileWriter (pour plus de possibilités voir la javadoc associée sous Eclipse)
Classe permettant de travailler sur des fichiers texte. Pour pouvoir utiliser cette classe vous
devez l'instanciée (créer un objet de ce type) en ajoutant les lignes de déclaration suivantes au
début de votre programme :
TxtFileReader txtFileR = new TxtFileReader(); // fichier en lecture
TxtFileWriter txtFileW = new TxtFileWriter(); // fichier en écriture
Ensuite vous disposez de différentes méthodes pour travailler en lecture :
txtFileR.open("D:/avare.txt"); // Ouverture du fichier spécifié en lecture
// ouverture d'un fichier se trouvant dans le répertoire ressource/texte du projet.
txtFileR.open(txtCode.class.getResource("texte/avare.txt"));
int c = txtFileR.readNextByteCode();
// lecture d'un octet dans le fichier
txtFileR.close();
// fermeture du fichier
et en ériture :
txtFileW.open("D:/avare.txt");
// Ouverture du fichier spécifié en écriture
txtFileW.writeNextByteCode(c);
// Ecriture d'un octet dans le fichier
txtFileW.close();
// fermeture du fichier
Exemple de programme utilisant le type TxtFileReader/TxtFileWriter :
import jisn.tools.*;
import java.awt.Color;
// Ligne à ajouter pour utiliser le type Color
public class copieFichierTexte {
static FrameWorkTxtCode fwtxt = new FrameWorkTxtCode("copie fichier texte");
public static void main(String[] args) {
TxtFileReader txtFileR = new TxtFileReader();
txtFileW.open("D:/avare.txt");
txtFileR.open(txtCode.class.getResource("texte/avare.txt"));
int c = txtFileR.readNextByteCode();
while (c != -1) {
txtFileW.writeNextByteCode(c);
c = txtFileR.readNextByteCode();
}
txtFileW.close();
txtFileR.close();
} // End main
} // End class
SocketServer/SocketClient
(pour plus de possibilités voir la javadoc associée sous Eclipse)
Classes permettant de travailler sur des socket en mode serveur. Chaque socketserver peut gérer
jusqu'à un maximum de 10 connections client. Chaque connection est identifiée à l'aide d'un numéro (de 0
à 9). Pour pouvoir utiliser cette classe vous devez l'instanciée (créer un objet de ce type) en ajoutant les
lignes de déclaration et de création suivantes au début de votre programme :
// Création du Socket serveur ( port 6000 )
SocketServer socketServer = new SocketServer(6000);
// Création du Socket client ( Adresse du serveur et port 6000 )
SocketClient socketClient = new SocketClient("127.0.0.1",6000);
Ensuite vous disposez de différentes méthodes pour travailler sur les connexions du serveur :
socketServer.start();
socketServer.setModeTrace(true);
// Démarrage du socket du serveur.
// Activation du mode trace
socketServer.getNbConnexion()
// retourne le nombre de connexion client en cours.
socketServer.getMessage(0);
socketServer.sendMessage(0,str);
// Récupère un message depuis la connexion Client 0
// Envoi un message depuis la connexion client 0
socketServer.close();
// fermeture du socket serveur
Et du client :
socketClient.start();
socketClient.setModeTrace(true);
// Démarrage du socket du client.
// Activation du mode trace
socketClient.getMessage();
socketClient.sendMessage(str);
// Récupère un message depuis du serveur
// Envoi un message vers le serveur
socketClient.close();
// fermeture du socket client
Exemple de programme utilisant les types SocketServer/SocketClient :
Server
import jisn.tools.*;
public class socketServerSample {
public static void main(String[] args) {
SocketServer socketServer = new SocketServer(6000);
socketServer.setModeTrace(true);
while (socketServer.getNbConnexion() < 1);
String str = socketServer.getMessage(0);
System.out.println(str);
socketServer.sendMessage(0,"Au revoir");
socketServer.close();
} // End Main
} // End Class
Client
import jisn.tools.*;
public class socketClientSample {
public static void main(String[] args) {
SocketClient socketClient;
socketClient = new SocketClient("127.0.0.1",6000);
socketClient.setModeTrace(true);
socketClient.sendMessage("Bonjour");
String str = socketClient.getMessage();
System.out.println(str);
socketClient.close();
} // End Main
} // End Class
FrameWorkGrid
(pour plus de possibilités voir la javadoc associée sous Eclipse)
Classe idéale pour la réalisation de jeux comme le morpion, la bataille navale, le memory, ...
Permet également de définir une calculatrice, un clavier de symboles, de musique,...
Elle est composée d'une grille de boutons clickables, de boutons de commande et d'une zone de
texte. A chaque bouton peut-être associé une marque de type caractère ou jusqu'à 4 images.
Boutons de commande
Grille de boutons
Bouton d'arrêt du
programme
Zone d'affichage
De type texte
Au niveau des boutons de commandes seul le bouton [Abort] est obligatoire. Il permet de quiter
propremen le programme en phase de développement.
Comment utiliser cette classe
Pour pouvoir utiliser cette classe vous devez l'instanciée (créer un objet de ce type) en ajoutant
la ligne de déclaration et de création suivante au début de votre programme :
//
//
//
//
Ici création d'une grille de 25 boutons (5 lignes, 5 colonnes) de taille 40x40
Les numérotation des lignes et colonnes commencent à partir de 0.
Le dernier paramètre à 0 indique que l'on ne définit aucun bouton de commande
hormis le bouton [Abort]
FrameWorkGrid fwgrid = new FrameWorkGrid("Titre de la fenêtre",5,5,40,40,0);
Fermeture de la fenêtre :
fwgrid.exit();
// fermeture de la fenêtre
Accès aux boutons de la grille et aux boutons de commande :
fwgrid.getCdeButton(0)
fwgrid.getGridButton(0,3)
// permet d'accéder au bouton de commande n°0
// permet d'accéder au bouton de la grille en position 0,3
Méthodes sur les boutons :
Dans ce qui suit, chaque référence à button peut-être remplacé par la référence à un
bouton précis de la grille comme : fwgrid.getGridButton(0,3)
exemple:
fwgrid.getGridButton(0,2).setMark('+',Color.white);
fwgrid.setGridButtonFontSize(16); // définit la taille de la police de tous les boutons.
button.setMark('+',Color.blue);
char c = button.getMark();
// Définit la marque et la couleur de fond du bouton
// Récupération de cette marque
button.setEnabled(true);
// Le bouton est “cliquable”
button.setEnabled(false);
// Le bouton est désactivé
button.setFlag(valeur);
int f = button.getFlag()
// Flag est une valeur entière que l'utilisateur
// peut utiliser à sa convenance
button.defineImage(img0,0);
button.defineImage(img1,1);
// On peut définir jusqu'a 4 images par
// bouton (indice de 0 à 3)
button.setImage(0);
// Spécifie quelle image afficher sur le bouton.
Remarque : le type JFWGButton utilisé dans cette classe dérive de la classe java Jbutton,
il hérite donc de toutes les méthodes disponibles sur les Jbutton.
Gestion de la sélection des boutons :
// Récupération du premier bouton “cliqué”. Cette méthode est bloquante et ne rend
// pas la main tant qu'aucun bouton n'est sélectionné. Elle renvoie le bouton sélectionné
buttonClicked = fwgrid.waitForButtonClicked();
// Les conditions ci-dessous permettent de savoir si le bouton “cliqué” est un bouton
// de commande ou de la grille. La gestion du type des boutons nécéssite de rajouter
// en début de programme : import jisn.tools.FrameWorkGrid.ButtonType;
(buttonClicked.getType() == ButtonType.CDEBUTTON)
(buttonClicked.getType() == ButtonType.GRIDBUTTON)
Gestion des clickGroup:
Chaque bouton peut-être associé à un “clickGroup”, qui correspond à un groupe de bouton identifié par un
numéro. Les clickGroup permettent de faciliter la gestion des différents types de boutons sur la grilles.
Le nombre de clickGroup n'est pas limité. Par défaut tous les boutons appartiennent au clickGroup 0.
button.setClickGroup(2);
// associe le bouton au clickGroup numéro 2
fwgrid.setEnabledButtonClickGroup(2,true);
// Active tous les boutons du groupe
fwgrid.setEnabledButtonClickGroup(2,false);
// Désactive tous les boutons du groupe
int n = fwgrid.buttonAvailableInclickGroup(0) // Renvoie le nombre de boutons cliquable
Action associée au bouton [Abort] :
Le rôle du bouton [Abort] est de permettre de quitter le programme proprement pendant la phase de
développement. En fermant par exemple des fichier ou des sockets ouverts au début du programme...
fwgrid.abortButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
//=========================================
//Rajouter ici les appels nécéssaires avant
// de quitter définitivement le programme.
//=========================================
fwgrid.exit(); // Ferme la fenêtre
}
});
Exemple de programme utilisant FrameWorkGrid :
import jisn.tools.*;
import jisn.tools.FrameWorkGrid.ButtonType;
import java.awt.*;
public class Calculatrice
{
static FrameWorkGrid fwgrid;
static JFWGButton buttonClicked;
public
static
void
main(String args[]) {
fwgrid = new FrameWorkGrid("Joueur",3,4,50,50,5);
fwgrid.setGridButtonFontSize(16);
fwgrid.abortButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
fwgrid.exit();
}
});
fwgrid.getCdeButton(0).setMark('+',Color.gray);
//....... Ici on définit les boutons opérateurs +,-,x,:
fwgrid.getCdeButton(4).setEnabled(true);
fwgrid.getGridButton(0,0).setMark('1', Color.white);
//...... Ici on définit tous les chiffres.
fwgrid.getGridButton(2,3).setMark(' ', Color.white);
fwgrid.show();
String s="" ;
// utilisé pour l'affichage
while (true) {
buttonClicked = fwgrid.waitForButtonClicked();
if (buttonClicked.getType() == ButtonType.CDEBUTTON) {
switch (buttonClicked.getMark()) {
case '+' : s = "+";
break;
case '-' : s = "-";
break;
case 'x' : s = "x";
break;
case '/' : s = "/";
break;
case '=' : s = "=";
break;
} // End switch
} else {
s = Character.toString(buttonClicked.getMark());
} // End if buttonClicked.getType()
s = String.format("%20s",s);
// Affichage fixe de 20 caractères
fwgrid.getTextInfo().setText(s);
} //End While (true)
} //End Main
}// End Class