package pg.coursjava.logo;



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

/**
 *
 * Un objet de cette classe définit une plume pour dessiner dans une "fenêtre Logo".<br>
 *
 * @author Philippe Genoud d'après Laurent Mounier
 * @version 16 février 1999
 */

public class Plume {

    // etat de la plume 

    private Pt ptCour = new Pt(0.0,0.0); // position courante de la plume
    private Pt ptSuiv = new Pt(0.0,0.0); // position suivante de la plume
    // utilise lors des deplacements de la plume, mais declarée ici pour éviter de créer des points
    // a chaque fois
    private boolean plumeBasse=true ;  // etat de la plume 
    private double plumeCap=0 ;      // cap de la plume en degrés
    private double plumeCapRad = 0.0;  // cap de la plume en radians

    private boolean visible = true; // visibilité de la plume, true par defaut

    private Fenetre f;

   /**
    * création d'un objet Plume.
    * @param f la fenêtre "Logo" dans laquelle la plume dessinera.
    */
    Plume(Fenetre f)
    {
       this.f = f;
    }

   /**
    * création d'un objet Plume.<br>
    * Attention, à sa création l'objet plume n'est associé à aucune fenêtre.<br>
    * Cette association se fera en passant l'objet plume en paramètre du constructeur 
    * de la fenêtre où la plume se dessinera.<br>
    * A sa création la plume est placée en (0.0 0.0), en position basse avec un cap de 0 
    * (sur axe des x positifs).
    */
    public Plume()
    {
    }

   /**
    * associe une fenêtre à un objet plume.
    * @param f la fenêtre "Logo" dans laquelle la plume dessinera.
    */
    void setFenetre(Fenetre f)
    {
       this.f = f;
    }

    /**
     * dessine la plume
     */
    void dessineToi(Graphics g)
    {   
      g.setColor(Color.green);
      double xt = f.offsetX + Math.round(ptCour.x);
      double yt = f.offsetY - Math.round(ptCour.y);
      g.fillOval((int)(xt - 5), (int)(yt -5), 10,10);
      g.drawLine((int)xt,(int)yt,
              (int)(xt + Math.round(10 * Math.cos(plumeCapRad))),
              (int)(yt - Math.round(10 * Math.sin(plumeCapRad)))); 
      g.setColor(Color.black);
    }

    /**
     *  Avance la plume d'une distance de "l" selon le cap courant.  Si la
     *   plume est basse, le segment correspondant au deplacement
     *   effectue est trace dans la fenetre.
     *  @param l longueur du deplacement
     */

   public void avance (double l) {
  
      ptSuiv.x = (ptCour.x + l * Math.cos(plumeCapRad)) ;
    	ptSuiv.y = (ptCour.y + l * Math.sin(plumeCapRad)) ;	
      if (plumeBasse) 
         f.afficheSegment(ptCour,ptSuiv);
      ptCour.x = ptSuiv.x ; ptCour.y = ptSuiv.y ;
   }

    /**
     *  Ajoute "a" degre au cap courant de la plume 
     *  (les angles sont orientes dans le sens trigonometrique).
     *  @param a la valeur (en degres) à ajouter au cap
     */
  public void tourne (double a) {
	
	plumeCap += a;
   plumeCap = (int)plumeCap % 360 + (plumeCap - (int) plumeCap);
	plumeCapRad = Math.PI * plumeCap/180.0;  // cap en radians
   f.repaint();
  } 


        
    /**
       * consulte la valeur du cap de la plume.
       * @return Valeur en degrés du cap.
       */
    public double getCap()
    {
      return plumeCap;
    }
    
    /**
       * fixe la valeur du cap de la plume.
       * @param v  Valeur (en degrés) à affecter au cap.
       */
    public void setCap(int  v)
    {
        plumeCap = v;	
        plumeCapRad = Math.PI * plumeCap/180.0;  // cap en radians
        f.repaint();
    }
    
    /**
       * fixe la valeur du cap de la plume.
       * @param v  Valeur (en degrés) à affecter au cap.
       */
    public void setCap(double  v)
    {
        plumeCap = v;	
        plumeCapRad = Math.PI * plumeCap/180.0;  // cap en radians
        f.repaint();
    }
    
    /**
     *  Leve la plume
     */
  public void leve () {

	plumeBasse = false ;
  } 

    /**
     *  Baisse la plume
     */
  public void baisse () {
	
	plumeBasse = true ;
  } 

    /**
     *  Positionne la plume sur un point donné.
     *  Si la plume est basse, le segment correspondant au deplacement
     *  effectue est trace dans la fenêtre.
     *  @param x abscisse du point où la plume est positionnée
     *  @param y ordonnée du point où la plume est positionnée
     */
   public void positionne (double x, double y) {

      ptSuiv.x = x; ptSuiv.y = y;
      if (plumeBasse) 
         {

            f.afficheSegment (ptCour, ptSuiv) ;
            ptCour.x = ptSuiv.x ; ptCour.y = ptSuiv.y ;
         }
      else
         {
            ptCour.x = ptSuiv.x ; ptCour.y = ptSuiv.y ;
            f.repaint();
         }
   }
 
    /**
     * Consultation de la position de la plume
     * @return la position de la plume
     */
  public Pt getPosition () {
       return ptCour; 
  } 

    /**
     * Consultation de l'etat de la plume (levŽe ou baissŽe).
     * @return true si la plume est baissŽe, false si elle est levŽe
     */
   public boolean plumeBasse()
    {
        return plumeBasse;
    }
   
   /**
    * consultation de la visibilité ou non de la plume.
    * @return true si la plume est visible, false sinon.
    */
   public boolean estVisible()
      {
         return visible;
      }

   /**
    * fixe la visibilité ou non de la plume.
    * @param v true la plume sera visible, false la plume ne sera plus visible
    */
    public void visible(boolean v)
      {
        visible = v;
        f.repaint();
      }


   /**
    * retourne une chaîne (String) représentant la plume
    * @return la chaîne représentant la pluem.<br>
    *           "je suis une Plume"<br>
    *           "ma position :  x = .. y =.."
    *           "mon cap : ..."
    *           "je suis levée" ou "je suis baissée"
    */
    public String toString()
      {
        return "Je suis une Plume\n" +
               "ma position : x = " + ptCour.x + " y = " + ptCour.y + "\n" +
               "mon cap : " + plumeCap + "\n" +
               "je suis " + ((plumeBasse)?"baissée\n":"levée\n");
      } 
}