Vu le nombre d'objets aiguilles (21) et zones (47), autant passer en C++.
Leurs classes sont définies au début du fichier :
// classe de base AIGUILLE Graphique
class GAiguille {
public:
boolean etat=true; // directe (true) ou deviee (false)
int no; // numéro de l'aiguille
int nz; // le numéro de Zone ou est l'aiguille
GAiguille(int n, int z) { no=n; nz=z; } // constructeur utilisé
boolean directe() { return etat; } // méthode de test
boolean deviee() { return !etat; } // méthode de test
void directer() {etat=true;} // mettre l'aiguille en position directe
void devier() {etat=false;} // mettre l'aiguille en position deviee
virtual void tracer(int c); // TCO c= couleur K_ouvert ou K_iti ou Kocc selon etat, K_ferme selon !etat
};
// classe de base ZONE Graphique
class GZone {
public:
boolean etat=false; // libre (false) ou occupé (true)
int no; // le numero de la zone pour commander l'electronique ( TCO, relais, ... )
int na=-1; // le numéro de l'aiguille dans la zone, sinon -1
int nb=-1; // le numéro de l'aiguille dans la zone, sinon -1
GZone(int n) { no=n; } // constructeur mini
GZone(int n,int a) { no=n; na=a; } // constructeur OPTION
GZone(int n,int a,int b) {no=n; na=a; nb=b;} // constructeur OPTION
void occuper() {etat=true;} // appelée par la rétrosignalisation lors de l'occupation d'une zone
void liberer() {etat=false;} // appelée par la rétrosignalisation lors de la liberation d'une zone
virtual void tracer(int c, boolean s); // TCO c= couleur K_ouvert ou K_iti ou Kocc selon etat, K_ferme selon !etat
};
Ces classes définissent les fonctions qu'il faudra appeler par le gestionnaire en fonction des occupations, libérations, manœuvres d'aiguilles, tracés graphiques.
Ces classes de base servent de modèle aux classes spécifiques de chaque zone et chaque aiguille.
Les classes aiguille sont dénommées GA0 à GA20.
par exemple :
class GA0: public GAiguille {
public:
GA0(int n,int z):GAiguille(n,z) { no=n; nz=z; } // constructeur utilisé
void tracer(int c);
};
void GA0::tracer(int c) {
if (etat) {//droit
myGLCD.setColor(K_ferme);
geo.drawArc(90, 358, 38, 0, 45, 5);
myGLCD.setColor(c);
drawbarreH(90, 320, 27);
}
else { // devié
myGLCD.setColor(K_ferme);
drawbarreH(90, 320, 27);
myGLCD.setColor(c);
geo.drawArc(90, 358, 38, 0, 45, 5);
}
}
GAiguille* Ga0 = new GA0(0,26); // a0 est dans la zone z26
On voit que le dessin d'une aiguille est la combinaison de segments de droite et d'arc avec 2 cas différents selon que l'aiguile est droite ou déviée.
De même, les classes zones sont dénommées de GZ0 à GZ46.
Par exemple :
class GZ2 : public GZone {
public:
//GZone(int n) { no=n; } // constructeur mini
GZ2(int n,int a):GZone(n,a) { no=n; na=a; } // constructeur OPTION
//GZone(int n,int a,int b) {no=n; na=a; nb=b;} // constructeur OPTION
void tracer(int c,boolean s); // TCO c= couleur K_ouvert ou K_iti ou Kocc selon etat, K_ferme selon !etat
};
void GZ2::tracer(int c, boolean s) {
myGLCD.setColor(c);
Ga15->tracer(c);
if (Ga15->directe()) {drawbarreH(547, 72, 26);}
myGLCD.setColor(K_trace);
if (Ga15->deviee()) {drawbarreH(547, 72, 26);} // Z2 contient a15
}
GZone* Gz2 = new GZ2(2,15);
On remarque ici, dans la zone 2 qu'il y a une aiguille 15, d'ou les appels aux fonctions graphiques de l'aiguille 15.
A la fin, pour manupuler les objets, les tables d'objets indexées sont créees :
////////////////////////// table des aiguilles
GAiguille* tableGA[MaxAig]= {
Ga0, Ga1, Ga2, Ga3, Ga4, Ga5, Ga6, Ga7, Ga8, Ga9, Ga10, Ga11,
Ga12, Ga13, Ga14, Ga15, Ga16, Ga17, Ga18, Ga19, Ga20 };
/////////////////// TABLE DES ZONES /////////////////
GZone* tableGZ[MaxZone]= {
Gz0, Gz1, Gz2, Gz3, Gz4, Gz5, Gz6, Gz7, Gz8, Gz9, Gz10, Gz11, Gz12, Gz13, Gz14, Gz15,
Gz16, Gz17, Gz18, Gz19, Gz20, Gz21, Gz22, Gz23, Gz24, Gz25, Gz26, Gz27, Gz28, Gz29, Gz30,
Gz31, Gz32, Gz33, Gz34, Gz35, Gz36, Gz37, Gz38, Gz39, Gz40, Gz41, Gz42, Gz43, Gz44, Gz45, Gz46 };
void drawallzones(int k) {
for (int i=0; i<MaxZone; i++)
{
tableGZ[i]->tracer(k, true);
}
}
////////////////////////////////////////////////////////////////////////////////////
On remarque la fonction drawallzones() qui sert à aficher l'ensemble du circuit au démarrage et lors des rafraichissements d'écran.
