I found my old code!HEADmaster

3 files changed, 321 insertions, 0 deletions

diff --git a/robottino/all_versions/v3.0/src/RobottinoUtils/Grafica.java b/robottino/all_versions/v3.0/src/RobottinoUtils/Grafica.java
new file mode 100755
index 0000000..84bc8c0
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/RobottinoUtils/Grafica.java
@@ -0,0 +1,226 @@
+// Dichiaro che questa classa farà parte del package RobottinoUtils, che verrà poi importato dalla classe Robottino.
+package RobottinoUtils;
+
+// Importo i package standard relativi al funzionamento delle finestre e della grafica in generale.
+import java.awt.*;
+
+// E i package RobottinoAzioni, RobottinoUtils e Immagini da me definiti.
+import RobottinoAzioni.*;
+import RobottinoUtils.Listener;
+import Immagini.*;
+
+// La classe è una sottoclasse di Frame per poter sfruttare gli effetti grafici
+// ma implementa anche l'interfaccia WindowListener, necessaria per gestire gli eventi collegati alle finestre
+// (riduzione a icona, chiusura...); per questo devo successivamente ridefinire tutti i
+// metodi dell'interfaccia.
+public class Grafica extends Frame {
+
+        // Creo un'istanza della classe Listener che userò come listener per gli eventi.
+        public static Listener listener;
+
+        // E una di ImmagineRobot per le immagini.
+        public static ImmagineRobot immagineRobot = new ImmagineRobot();
+
+        // Il costruttore senza argomenti.
+        public Grafica () {
+
+                // Il metodo "setBounds" posiziona e dimensiona la finestra.
+                setBounds (this.orizzontale, this.verticale, this.larghezza, this.altezza);
+
+                // "setTitle" per il titolo della finestra.
+                setTitle ("Robottino v2.2");
+
+                // "setVisible" per poterla visualizzare.
+                setVisible (true);
+
+                // E addWindowListener per l'ascoltatore (listener).
+                listener = new Listener();
+                addWindowListener (listener);
+
+                // Aggiungo la barra del menu con i vari sottomenu
+                setMenuBar (barraMenu);
+
+                // Il menu file.
+                NewRobot.addActionListener(listener);
+                NewRobot.setActionCommand("newrobot");
+
+                ChangeRobot.addActionListener(listener);
+                ChangeRobot.setActionCommand("changerobot");
+
+                DeleteRobot.addActionListener(listener);
+                DeleteRobot.setActionCommand("deleterobot");
+
+                Exit.addActionListener(listener);
+                Exit.setActionCommand("exit");
+
+                file.add(NewRobot);
+                file.add(ChangeRobot);
+                file.add(DeleteRobot);
+                file.addSeparator();
+                file.add(Exit);
+
+                barraMenu.add(file);
+
+                // Il braccio sinistro.
+                LeftArmMove.addActionListener(listener);
+                LeftArmMove.setActionCommand("leftarmmove");
+
+                LeftArmOn.addActionListener(listener);
+                LeftArmOn.setActionCommand("leftarmon");
+
+                LeftArmOff.addActionListener(listener);
+                LeftArmOff.setActionCommand("leftarmoff");
+
+                LeftArm.add(LeftArmMove);
+                LeftArm.add(LeftArmOn);
+                LeftArm.add(LeftArmOff);
+
+                // Il braccio destro.
+                RightArmMove.addActionListener(listener);
+                RightArmMove.setActionCommand("rightarmmove");
+
+                RightArmOn.addActionListener(listener);
+                RightArmOn.setActionCommand("rightarmon");
+
+                RightArmOff.addActionListener(listener);
+                RightArmOff.setActionCommand("rightarmoff");
+
+                RightArm.add(RightArmMove);
+                RightArm.add(RightArmOn);
+                RightArm.add(RightArmOff);
+
+                // La gamba sinistra.
+                LeftLegMove.addActionListener(listener);
+                LeftLegMove.setActionCommand("leftlegmove");
+
+                LeftLegOn.addActionListener(listener);
+                LeftLegOn.setActionCommand("leftlegon");
+
+                LeftLegOff.addActionListener(listener);
+                LeftLegOff.setActionCommand("leftlegoff");
+
+                LeftLeg.add(LeftLegMove);
+                LeftLeg.add(LeftLegOn);
+                LeftLeg.add(LeftLegOff);
+
+                // La gamba destra.
+                RightLegMove.addActionListener(listener);
+                RightLegMove.setActionCommand("rightlegmove");
+
+                RightLegOn.addActionListener(listener);
+                RightLegOn.setActionCommand("rightlegon");
+
+                RightLegOff.addActionListener(listener);
+                RightLegOff.setActionCommand("rightlegoff");
+
+                RightLeg.add(RightLegMove);
+                RightLeg.add(RightLegOn);
+                RightLeg.add(RightLegOff);
+
+                // Menu rinomina.
+                Rename.addActionListener(listener);
+                Rename.setActionCommand("rename");
+
+                Menu modifica = new Menu("Modifica");
+                modifica.add(LeftArm);
+                modifica.add(RightArm);
+                modifica.add(LeftLeg);
+                modifica.add(RightLeg);
+                modifica.addSeparator();
+                modifica.add(Rename);
+
+                barraMenu.add(modifica);
+
+                // Menu azioni.
+                Exploud.addActionListener(listener);
+                Exploud.setActionCommand("exploud");
+
+                Bier.addActionListener(listener);
+                Bier.setActionCommand("bier");
+
+                xxx.addActionListener(listener);
+                xxx.setActionCommand("xxx");
+
+                Dance.addActionListener(listener);
+                Dance.setActionCommand("dance");
+
+                azioni.add(Exploud);
+                azioni.add(Bier);
+                azioni.add(xxx);
+                azioni.add(Dance);
+
+                barraMenu.add(azioni);
+
+                // Menu info.
+                Porky.addActionListener(listener);
+                Porky.setActionCommand("porky");
+
+                l.addActionListener(listener);
+                l.setActionCommand("l");
+
+                RobotList.addActionListener(listener);
+                RobotList.setActionCommand("robotlist");
+
+                info.add(Porky);
+                info.add(l);
+                info.add(RobotList);
+
+                barraMenu.add(info);
+        }
+
+        // Le variabili pubbliche di classe per il metodo "setBounds".
+        public int orizzontale = 0;
+        public int verticale = 0;
+        public int larghezza = 360;
+        public int altezza = 550;
+
+        // E i vari Menu e MenuItem.
+        MenuBar barraMenu = new MenuBar();
+        Menu file = new Menu("File");
+        MenuItem NewRobot = new MenuItem("Nuovo robot");
+        MenuItem ChangeRobot = new MenuItem("Dai i comandi a un altro robot");
+        MenuItem DeleteRobot = new MenuItem("Elimina un robot");
+        MenuItem Exit = new MenuItem("Esci");
+        Menu LeftArm = new Menu("Braccio sinistro");
+        MenuItem LeftArmMove = new MenuItem("Cambia posizione");
+        MenuItem LeftArmOn = new MenuItem("Alza");
+        MenuItem LeftArmOff = new MenuItem("Abbassa");
+        Menu RightArm = new Menu("Braccio destro");
+        MenuItem RightArmMove = new MenuItem("Cambia posizione");
+        MenuItem RightArmOn = new MenuItem("Alza");
+        MenuItem RightArmOff = new MenuItem("Abbassa");
+        Menu LeftLeg = new Menu("Gamba sinistra");
+        MenuItem LeftLegMove = new MenuItem("Cambia posizione");
+        MenuItem LeftLegOn = new MenuItem("Alza");
+        MenuItem LeftLegOff = new MenuItem("Abbassa");
+        Menu RightLeg = new Menu("Gamba destra");
+        MenuItem RightLegMove = new MenuItem("Cambia posizione");
+        MenuItem RightLegOn = new MenuItem("Alza");
+        MenuItem RightLegOff = new MenuItem("Abbassa");
+        MenuItem Rename = new MenuItem("Rinomina");
+        Menu azioni = new Menu("Azioni");
+        MenuItem Exploud = new MenuItem("Esplodi");
+        MenuItem Bier = new MenuItem("Birra");
+        MenuItem xxx = new MenuItem("xxx");
+        MenuItem Dance = new MenuItem("Balla");
+        Menu info = new Menu("?");
+        MenuItem Porky = new MenuItem("Informazioni sul programmatore");
+        MenuItem l = new MenuItem("Legenda Comandi");
+        MenuItem RobotList = new MenuItem("Lista robot");
+
+
+        // Il metodo per disegnare l'immagine del robot.
+        public void paint(Graphics g){
+                g.drawImage(immagineRobot.robot, 100, 60, this);
+                g.drawImage(immagineRobot.raoff, 66, 248, this);
+                g.drawImage(immagineRobot.laoff, 225, 242, this);
+                g.drawImage(immagineRobot.rloff, 84, 367, this);
+                g.drawImage(immagineRobot.lloff, 148, 367, this);
+        }
+
+
+}
+
+
+
+
diff --git a/robottino/all_versions/v3.0/src/RobottinoUtils/Listener.java b/robottino/all_versions/v3.0/src/RobottinoUtils/Listener.java
new file mode 100755
index 0000000..d9c813a
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/RobottinoUtils/Listener.java
@@ -0,0 +1,73 @@
+// Questa classe è il listener per gli eventi relativi alle finestre.
+// Dichiaro che farà parte del package RobottinoUtils
+package RobottinoUtils;
+
+// Importo i package necessari.
+import java.awt.event.*;
+import RobottinoMain.*;
+import RobottinoAzioni.*;
+
+public class Listener implements WindowListener, ActionListener {
+
+        RobottinoAzioni robottinoazioni = new RobottinoAzioni();
+
+
+        // Ridefinisco i metodi dell'interfaccia WindowListener:
+        // Metodo invocato quando la finestra è stata chiusa:
+        public void windowClosed (WindowEvent evt) {
+
+                // Invoco il metodo sleep(int millisecondi) per mettere il programma in uno stato di attesa
+                // di durata pari ai millisecondi indicati come argomento.
+                System.out.println("La finestra è stata chiusa, il programma terminarà fra 3 secondi");
+                try {
+                        Robottino.robottino.threadMain.sleep(1000);
+                } catch (Exception e) { e.printStackTrace(); }
+                System.out.println("2");
+                try {
+                        Robottino.robottino.threadMain.sleep(1000);
+                } catch (Exception e) { e.printStackTrace(); }
+                System.out.println("1");
+                try {
+                        Robottino.robottino.threadMain.sleep(1000);
+                } catch (Exception e) { e.printStackTrace(); }
+                System.out.println("Programma terminato");
+                System.exit(0);
+        }
+
+        // Metodo invocato quando la finestra è in fase di chiusura:
+        public void windowClosing (WindowEvent evt) {
+                System.out.println ("Chiusura finestra in corso");
+                evt.getWindow().dispose();
+        }
+
+        // Metodo invocato quando una finestra viene ridotta a icona:
+        public void windowIconified (WindowEvent evt) {
+                System.out.println("La finestra è stata ridotta a icona");
+        }
+
+        // Metodo invocato quando una finestra ridotta a icona viene ingrandita:
+        public void windowDeiconified (WindowEvent evt) {
+                System.out.println("La finestra ridotta a icona è stata ingrandita");
+        }
+
+        // Metodo invocato quando una finestra viene aperta:
+        public void windowOpened (WindowEvent evt) {}
+
+        // Metodo invocato quando una finestra diventa attiva:
+        public void windowActivated (WindowEvent evt) {}
+
+        // Metodo invocato quando una finestra viene disattivata:
+        public void windowDeactivated (WindowEvent evt) {}
+
+        // Metodo invocato quando viene utilizzata la barra del menu:
+        // descrive tutte le azioni da compiere per ogni evento ricevuto
+        // dal menu.
+        public void actionPerformed (ActionEvent e) {
+                System.out.println (robottinoazioni.Azioni(e.getActionCommand(), RobottinoAzioni.nomeRobot, RobottinoAzioni.pdrA));
+        }
+}
+
+
+
+
+
diff --git a/robottino/all_versions/v3.0/src/RobottinoUtils/PartiDelRobot.java b/robottino/all_versions/v3.0/src/RobottinoUtils/PartiDelRobot.java
new file mode 100755
index 0000000..d6cf869
--- /dev/null
+++ b/robottino/all_versions/v3.0/src/RobottinoUtils/PartiDelRobot.java
@@ -0,0 +1,22 @@
+// Dichiaro che questa classa farà parte del package RobottinoUtils, che verrà poi importato dalla classe Robottino.
+package RobottinoUtils;
+
+// Dichiaro la classe.
+public class PartiDelRobot {
+
+        // Creo un costruttore senza argomenti.
+        // Se non lo facessi sarei obbligato a passare gli argomenti
+        // del secondo costruttore ogni volta che voglio istanziare la classe.
+        public PartiDelRobot() {}
+
+        // Il secondo costruttore riceve come argomenti un booleano che passerà il valore a "statoParte"
+        // e una stringa che passa il valore a "stringaParte".
+        public PartiDelRobot(boolean b, String s) {
+                this.stringaParte = s;
+                this.statoParte = b;
+        }
+
+        // Infine le due variabili pubbliche della classe.
+        public String stringaParte;
+        public boolean statoParte;
+}