/* LanceBou.java     (cf. FenetreA, Animation, Boule) <xmp>
 Une boule tourne tous les 300/1000 de seconde (cf. constante attente)
 Un bouton permet d'arrêter ou de relancer la rotation de la boule:
    voir la gestion des événements par actionListener.
 Un bouton permet de fermer la fenêtre.

 Remarques: on trouve dans cet exemple
   + vérification de la conversion d'un argument de la commande
   + démarrage, interruption et reprise d'une activité (thread)
   + deux gestionaires d'événement mis en place
   + rafraichissement du contenu d'une fenêtre
   + fermeture surveillée de la fenêtre principale
*/

/* Travailler sans package:
   un seul fichier .java dans le répertoire du projet.
*/

import java.awt.*;
import java.awt.event.*;



public class LanceBou {
  final static int attente=300;

  public static void main(String[] tm) {
  int aa=attente;
  try  {
     if(tm.length>0) { aa = Integer.parseInt(tm[0]); }
     }
  catch (NumberFormatException e) {
     System.out.println(" "+ e.getLocalizedMessage() +
              " argument incorrect (valeur par defaut:" + aa + ")\n");
     }
  System.out.println("attente(10-3sec;):"+aa);
  FenetreA fen = new FenetreA(aa);
  fen.setLocation(100,300);
  fen.validate();
  fen.setVisible(true);
  }
}   // fin class LanceBou

// FenetreA.java     (cf. LanceAct.java)

/** FenetreA : fenetre sensible aux événements WindowEvent, dans
    laquelle un cercle est tracé.
*/
class FenetreA extends Frame
                   implements WindowListener, ActionListener {

  // Une fenêtre
  BorderLayout gg = new BorderLayout();
  int n_e_fermer;
  // Panneau supérieur:
  // Un bouton pour arrêter la boule et un pour quitter l'application
  Panel barre;
  Button arret = new Button("   arreter   ")
       ,  quit = new Button("quitter"); ;
  // Une boule sous la barre de boutons
  int margeh, margeg;
  Boule boule;

/** Création d'une fenêtre contenant deux boutons; quand
     on ferme cette fenêtre le programme est terminé.
*/
public FenetreA(int att) {
  addWindowListener(this);               //V1.1
  this.setLayout(gg);
  this.setSize(new Dimension(300, 300));
  this.setTitle("Fenêtre de 300x300");

  // Panneau supérieur et ses 2 boutons (quitter l'application)
  barre = new Panel();
  barre.add(arret);
  barre.add(quit);
  add(barre,"North");

  // Un bouton pour arrêter la boule et un pour
  quit.addActionListener(this);

  // Définir la boule et son comportement
  boule = new Boule(this);
  Animation anim = new Animation(this, att);
  arret.addActionListener(anim);
  }


/** Pour retracer les éléments dans la fenêtre
*/
public void tracer_fen(Graphics cg) {
  Dimension dim = this.getSize();
  int r = (Math.min(dim.width,dim.height-margeh)/2)-margeg;
  boule.tracer( cg, new Point(margeg,margeh), r);
  //System.out.println( " marges "  + margeg + ',' + margeh);
  }

/** Pour tester si on peut fermer la fenêtre
*/
private void fermer( String ch ) {
  n_e_fermer++;
  if( n_e_fermer == 2 ) System.exit(0);
  else System.out.println( ch + " essai " + n_e_fermer);
  }

// Les différents gestionnaires d'événement

public void paint(Graphics cg) {
  tracer_fen(cg);
  }

/** Pour les divers événements WindowEvent */
public void windowActivated( WindowEvent e ) {
  }
public void windowClosed( WindowEvent e ) {
  }
public void windowClosing( WindowEvent ev ) {
  Point p =  ev.getComponent().getLocation();
  System.out.println("Position: " + p.x + ", " + p.y);
  fermer(ev.toString());
  }
public void windowDeactivated( WindowEvent e ) {
  }
public void windowDeiconified( WindowEvent e ) {
  }
public void windowIconified( WindowEvent e ) {
  }
public void windowOpened( WindowEvent ev ) {
  n_e_fermer=0;
  System.out.println( ev.toString() + " fenetre ouverte");
  Point p = new Point(ev.getComponent().getLocation());
  System.out.println("Position: " + p.x + ", " + p.y);
  // Récupérer les dimensions de la barre
  margeg = barre.getLocation().x;
  margeh = barre.getLocation().y + barre.getSize().height;
  }


/*  Traitement des événements ActionEvent
*/
public void actionPerformed( ActionEvent ev) {
  Button b = (Button) ev.getSource();
  Container p1 = b.getParent();
  System.out.println( "source: " + b.getLabel() +
                      " parent: " + p1.getClass());
  fermer( ev.toString() );
  }
}   // fin class FenetreA

  //  //  //  //  //  //  //  //  //  //  //  //  //  //  //  //  //  //

class Animation implements ActionListener, Runnable {
   FenetreA fen;
   int attente;
   boolean actif;
   Thread act;

   Animation(FenetreA f, int att) {
   fen = f;
   attente=att;
   actif = true;
   act = new Thread(this);
   act.start();
   }
/** Arrête ou relance la rotation de la boule
*/
public synchronized void actionPerformed( ActionEvent ev) {
   Button b = (Button) ev.getSource();
   if(actif) {  // Changer le libellé du bouton (avant d'interrompre)
      b.setLabel("demarrer");
      // act.suspend();
      }
   else {      // Changer le libellé du bouton
      b.setLabel("arreter");
      // act.resume();
      }
   actif = !actif;
   if(actif) notify();
   System.out.println( "Animation.actionP..ed() " + actif);
   Container p1 = b.getParent();
   System.out.println( "source: " + b.getLabel() +
                      " parent: " + p1.getClass());
   Point p = new Point(p1.getLocation());
   System.out.println( "Animation.actionP..ed Position barre: "
                     + p.x+", "+p.y);
   }

public void run() {
   System.out.println( "Animation.run() " + actif);
   while(true) {
      try  {
         Thread.sleep(attente);
         synchronized(this) { while (!actif) wait();  }
         }
      catch (Exception e) {
         System.out.println(" "+ e.getLocalizedMessage());
         }
      fen.boule.rotationPts();
      fen.repaint();
      }
  }
}  // fin class class Animation

  //  //  //  //  //  //  //  //  //  //  //  //  //  //  //  //  //  //

class Boule {
  final int nbp=11;                     // nombre de pts sur la boule
  final double rot=2*Math.PI/(nbp*5);   // angle de rotation
  double teta0;                         // angle initial
  int xc,yc, r;
  double ptsX[], ptsY[];

  public Boule(  Frame fen) {
  Dimension dim = fen.getSize();
  // Les points
  System.out.println( "Boule "+dim.width+','+dim.height);
  teta0=0;
  ptsX = new double[nbp];
  ptsY = new double[nbp];
  rotationPts();
  }

/** Fait tourner les points sur la circonférence de la boule (et calcule
   les nouvelles coordonnées).
*/
public void rotationPts() {
  int i,j;
  double teta, pas=2*Math.PI/nbp;
  teta0 += rot; if(teta0 > pas) teta0 = rot;
  // Calcul des coordonnées de nbp points sur la circonférence
  for( i=0, teta=teta0; i<nbp; i++, teta+=pas) {
     ptsX[i] = Math.cos(teta);
     ptsY[i] = Math.sin(teta);
     }
  }

/**  Trace une boule en tracant la circonférence et des cordes entre
     des points de la circonférence
*/
  public void tracer(Graphics cg, Point pos, int  r) {
  int i,j, x1,y1, xc, yc;
  xc=pos.x+r; yc=pos.y+r;
  cg.clearRect(xc-r,yc-r,2*r,2*r);
  cg.drawOval(xc-r,yc-r,2*r,2*r);
  for( i=0; i<nbp; i++) {
     x1 = xc+(int)(r*ptsX[i]);
     y1 = yc+(int)(r*ptsY[i]);
     for(j =i+1; j<nbp; j++) {
        cg.drawLine( x1, y1, xc+(int)(r*ptsX[j]), yc+(int)(r*ptsY[j]));
        }
     }
  }
}

// fin LanceBou.java </xmp>