Commit 51df9e20 authored by Zéfling's avatar Zéfling 🎨
Browse files

Code réalisé lors d'un TP de Java

parents
package net.ikilote.calculatrice;
/**
* Énumération des actions possibles pour les boutons de la calculatrice.
*
* @author Célian Veyssière
* @version 0.0.6
* @since 2011.02.04
* @license : <a href="http://www.gnu.org/licenses/gpl-3.0.html">GPL3</a>
*/
public enum ActionEnum {
// chiffres
ZERO, UN, DEUX, TROIS, QUATRE, CINQ, SIX, SEPT, HUIT, NEUF,
// actions
RIEN, CE, BACK, PLUS, MOINS, DIV, MULT, PLUSMOINS, POURCENT, VIRGULE, EGALE
}
package net.ikilote.calculatrice;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
/**
* Génération des boutons de calculatrice.
*
* @author Célian Veyssière
* @version 0.0.6
* @since 2011.02.04
* @license : <a href="http://www.gnu.org/licenses/gpl-3.0.html">GPL3</a>
*/
public class BoutonCalc extends JButton implements ActionListener {
// taille des boutons
private static Dimension d = new Dimension(50, 25);
// frame du programme
private CalculatriceFrame frame;
// action du bouton
private ActionEnum action;
/**
* Création du bouton
* @param string le nom du bouton
* @param action l'action definit pour le bouton
* @param frame lien vers la frame mère
*/
public BoutonCalc(String string, ActionEnum action, CalculatriceFrame frame) {
super(string);
this.frame = frame;
this.action = action;
// le bouton s'écoute
this.addActionListener(this);
// défini la taille du du bouton
this.setPreferredSize(d);
}
/**
* Envoie l'action au controleur
* @param e evenement
*/
@Override
public void actionPerformed(ActionEvent e) {
frame.calc(action);
}
}
package net.ikilote.calculatrice;
import static net.ikilote.calculatrice.ActionEnum.*;
/**
* Traitement des données de la calculatrice en fonction des actions envoyés par la vue
*
* @author Célian Veyssière
* @version 0.0.6
* @since 2011.02.04
* @license : <a href="http://www.gnu.org/licenses/gpl-3.0.html">GPL3</a>
*/
public class Calc {
private CalculatriceFrame frame;
private boolean virgule;
private boolean pourcent;
private boolean signe;
private boolean egale;
private boolean resultat;
private String val;
private double calc;
private ActionEnum operateur;
/**
* Initalise la calculatrice
* @param calculatriceFrame
*/
public Calc(CalculatriceFrame calculatriceFrame) {
this.frame = calculatriceFrame;
initialise();
etat();
}
/**
* Ré-initalise toutes les informations
*/
private void initialise() {
effacerInfos();
this.calc = 0.0;
this.val = "0";
this.operateur = RIEN;
afficher();
this.resultat = false;
}
/**
* Efface juste les informations nécessaires pour une valeur courante
*/
private void effacerInfos() {
this.signe = false;
this.virgule = false;
this.pourcent = false;
this.egale = false;
}
/**
* Distribue les actions en fonction de l'action envoyée
* @param action action effectuée
*/
public void action(ActionEnum action) {
if (action.ordinal() < 10) {
if (egale) {
initialise();
}
if (resultat) {
effacerInfos();
val = "0";
resultat = false;
}
ajout(String.valueOf(action.ordinal()));
resultat = false;
} else {
switch(action) {
case EGALE :
egale ();
break;
case CE :
initialise();
break;
case BACK :
backsuppr();
break;
case PLUS :
case DIV :
case MULT :
case MOINS :
operation(action);
//afficher();
break;
case VIRGULE :
if (egale) {
initialise();
}
if(!virgule) {
effacerInfos();
virgule = true;
if (resultat) ajout("0");
ajout(",");
}
break;
case PLUSMOINS :
if(!egale) {
signe = !signe;
afficher();
}
break;
case POURCENT :
if(!egale) {
pourcent = !pourcent;
afficher();
}
break;
default : ;
}
}
etat();
}
/**
* calcule le résulat et l'affiche
*/
private void egale() {
//if (!egale) {
calculer();
//effacerInfos();
virgule = false;
afficher(calc);
egale = true;
//}
}
/**
* retourne la chaine en valeur numérique
* @return la valeur affichée
*/
private double courant() {
return Double.valueOf(val.replace(",", "."));
}
/**
* Éffecter la demande d'operation, si c'est possible
* @param action
*/
private void operation(ActionEnum action) {
/*if(egale) {
effacerInfos();
operateur = action;
egale = false;
} else {*/
if(resultat == false) {
if (operateur != null) {
calculer();
} else {
calc = courant();
}
//effacerInfos();
operateur = action;
} else {
operateur = action;
egale = false;
}
//}
}
/**
* effectue le calcule suivant l'opérateur
*/
private void calculer() {
double negatif = signe ? -1.0 : 1.0;
double facteur = pourcent ? 100.0 : 1.0;
double valeur = !pourcent ? courant() : calc * courant();
switch (operateur) {
case PLUS :
calc += negatif * valeur/ facteur;
break;
case MOINS :
calc -= negatif * valeur/ facteur;
break;
case MULT :
calc *= negatif * valeur/ facteur;
break;
case DIV :
calc /= negatif * valeur/ facteur;
break;
default :
calc = negatif * valeur / facteur;
}
resultat = true;
afficher(calc);
}
/**
* suppression arrière, et affichage
*/
private void backsuppr() {
if(!egale) {
if ( val.length() == 1) {
val = "0";
} else {
int pos = val.length()-1;
if (val.charAt(pos) == ',') {
virgule = false;
}
val = val.substring(0, pos);
}
afficher();
}
}
/**
* Ajout la valeur, et affichage
* @param num une chaîne à ajouter à l'affichage
*/
private void ajout(String num) {
// supprimer le premier zéro si nécessaire
if (resultat || val.equals("0") && !num.equals(",")) {
val = "";
resultat = false;
}
// ajouter la valeur en fin
val = val + num;
afficher();
}
/* ************** retour cadran ************** */
/**
* Envoie l'affichage à la vue de la valeur en mémoire
*/
private void afficher() {
frame.affiche(
(signe ? "-" : "") +
val.replace(".", ",") +
(pourcent ? ("% ("+ pourcent() + ")") : "")
);
}
/**
* Affichage de la partie des poucentages
* @return le calcule en pourcent part rapport à la valeur précédente
*/
private double pourcent() {
double negatif = signe ? -1.0 : 1.0;
double facteur = pourcent ? 100.0 : 1.0;
return negatif * calc * courant() / facteur;
}
/**
* Envoie l'affichage à la vue
* @param r
*/
private void afficher(double r) {
frame.affiche(String.valueOf(r).replace(".", ","));
}
/* ************** retour bouton ************** */
/**
* Change l'état des boutons en fonction de l'état de différents paramètres
*/
private void etat() {
etatBouton(VIRGULE, !virgule );
etatBouton(PLUSMOINS, !egale && !resultat);
etatBouton(POURCENT, !egale && !resultat);
etatBouton(BACK, !egale && !val.equals("0") && !resultat);
etatBouton(CE, !(calc == 0 && val.equals("0") && !signe && !virgule));
// si on veut que les boutons ne soit pas reclicable, vu que ça ne fait rien
//etatBouton(MOINS, !resultat || operateur != MOINS);
//etatBouton(PLUS, !resultat || operateur != PLUS);
//etatBouton(MULT, !resultat || operateur != MULT);
//etatBouton(DIV, !resultat || operateur != DIV);
}
/**
* Change l'état d'un bouton
* @param num le bouton
* @param etat l'état (activé ou non)
*/
private void etatBouton(ActionEnum num, boolean etat) {
frame.changer(num, etat);
}
}
package net.ikilote.calculatrice;
/**
* Lance l'application et son interface graphique.
*
* @author Clian Veyssire
* @version 0.0.6
* @since 2011.02.04
* @license : <a href="http://www.gnu.org/licenses/gpl-3.0.html">GPL3</a>
*/
public class Calculatrice {
/**
* lanceur de l'appication
* @param args paramtres
*/
public static void main(String[] args) {
// lance swing dans un thread part
javax.swing.SwingUtilities.invokeLater(
new Runnable() {
public void run () {
new CalculatriceFrame();
}
}
);
}
}
package net.ikilote.calculatrice;
import java.awt.AWTEvent;
import java.awt.BorderLayout;
import java.awt.Toolkit;
import javax.swing.JFrame;
import javax.swing.JPanel;
/**
* Cration de la Frame de la calculatrice
*
* @author Clian Veyssire
* @version 0.0.6
* @since 2011.02.04
* @license : <a href="http://www.gnu.org/licenses/gpl-3.0.html">GPL3</a>
*/
public class CalculatriceFrame extends JFrame {
// panneau cadran
private PanelCadran c;
// panneau bouton
private PanelBoutons panelBoutons;
// calculateur
private Calc calc;
//menu
private CalculatriceMenu menu;
/**
* Gnre la fentre
*/
public CalculatriceFrame() {
super();
// initialise la fentre de l'application
this.initialise();
this.setTitle("Calculatrice");
// ajout de la barre de menu
menu = CalculatriceMenu.getMenu(this);
this.setJMenuBar(menu);
// groupe pour panels
JPanel j = new JPanel();
j.setLayout(new BorderLayout());
// gnre les panels cadrant et boutons
c = new PanelCadran(this);
j.add(c, BorderLayout.NORTH);
panelBoutons = new PanelBoutons(this);
j.add(panelBoutons, BorderLayout.CENTER);
// ajout la frame
this.setContentPane(j);
calc = new Calc(this);
}
/**
* Initualise la fentre de l'application
*/
public void initialise() {
this.setDefaultCloseOperation(EXIT_ON_CLOSE); // fermeture
this.setSize(250, 250); // taille de la fentre
this.setLocationRelativeTo(null); // centre
this.setVisible(true); // affiche
this.setResizable(false); // non redimensionnable
Toolkit.getDefaultToolkit().addAWTEventListener(new ClavierAWT(this), AWTEvent.KEY_EVENT_MASK);
}
/**
* rpercute l'action vers le calculateur
* @param action action dfini par un bouton press
*/
public void calc(ActionEnum action) {
calc.action(action);
}
/**
* renvoie l'affichage au cadran
* @param val la chaine a afficher dans le cadran
*/
public void affiche(String val) {
this.c.getTexte().setText(val);
}
/**
* renvoie l'tat d'un bouton
* @param bouton l'identifiant du bouton
* @param etat tat du bouton
*/
public void changer(ActionEnum bouton, boolean etat) {
this.panelBoutons.setBoutonEtat(bouton, etat);
}
/**
* Envoie aux boutons lequel est a presser
* @param bouton l'identifiant du bouton
*/
public void boutonPress(ActionEnum bouton) {
this.panelBoutons.pressBouton(bouton);
}
}
package net.ikilote.calculatrice;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
/**
* Cration du menu
*
* @author Clian Veyssire
* @version 0.0.6
* @since 2011.02.04
* @license : <a href="http://www.gnu.org/licenses/gpl-3.0.html">GPL3</a>
*/
public class CalculatriceMenu extends JMenuBar {
/* *********** SINGLETON DU MENU ************************* */
private static CalculatriceMenu menu;
public static CalculatriceMenu getMenu(CalculatriceFrame frame) {
if (menu == null) {
menu = new CalculatriceMenu(frame);
}
return menu;
}
/* *********** MENU ************************************** */
private final CalculatriceFrame frame;
private CalculatriceMenu(CalculatriceFrame frame) {
super();
this.frame = frame;
/* *********************** Calculatrice ************************* */
JMenu menuFichier = new JMenu("Calculatrice");
menuFichier.setMnemonic('C');
// Item : propos...
JMenuItem menuItemQuitter = new JMenuItem("Quitter");
menuItemQuitter.setMnemonic('Q');
menuItemQuitter.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) { System.exit(0);}
});
menuFichier.add(menuItemQuitter);
this.add(menuFichier);
/* ************************* ? ************************* */
JMenu menuAide = new JMenu("?");
menuAide.setMnemonic('?');
// Item : Raccourcis Clavier
JMenuItem menuItemCalvier = new JMenuItem("Raccourcis Clavier");
menuItemCalvier.setMnemonic('R');
menuItemCalvier.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) { CalculatriceMenu.this.clavier();}
});
menuAide.add(menuItemCalvier);
// Item : propos...
JMenuItem menuItemVersion = new JMenuItem(" propos...");
menuItemVersion.setMnemonic('P');
menuItemVersion.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) { CalculatriceMenu.this.apropos();}
});
menuAide.add(menuItemVersion);
this.add(menuAide);
}
/**
* Affiche les Raccourcis Clavier du logiciel
*/
protected void clavier() {
JOptionPane.showMessageDialog(
frame,
"0 9 pour les chiffres\n" +
"+ : Touche + * : Touche \n" +
"- : Touche - / : Touche \n" +
"P : Touche % M : Touche \n" +
"chap : Touche CE",
"Raccoucis Clavier",
JOptionPane.INFORMATION_MESSAGE
);
}
/**
* Affiche le propos du logiciel
*/
protected void apropos() {
JOptionPane.showMessageDialog(