// Copyright 2004-2005, FreeHEP.
   package hep.wired.edit;
   
   import java.awt.*;
   import java.awt.geom.*;
   import java.util.logging.*;
   import javax.swing.*;
   import javax.swing.undo.*;
   
  import hep.wired.services.RecordPlot;
  import hep.wired.services.GraphicsPanel;
  import hep.wired.util.Matrix3D;
  import hep.wired.feature.Rotateable2D;
  import hep.wired.feature.Rotateable3D;
  
  /***
   * Rotates a plot in 2D or 3D.
   *
   * @author Mark Donszelmann
   * @version $Id: Rotate.java 689 2005-03-16 09:06:57Z duns $
   */
  public class Rotate extends AnimatedWiredEdit implements GraphicsPanelEdit {
  
      private static Logger logger = Logger.getLogger(Rotate.class.getPackage().getName());
      
      // Note: due to precision problems, we keep both the matrix (int the last edit)
      // and vector and theta in each edit. 
      // We use vector and theta for the actual changes, while we use the matrix
      // to display the redo/undo presentation name.
      // FIXME WIRED-224 We need to decide if we implement rotate with a orthonormalized matrix
      // rather than extracting a vector and an angle
      private double nx, ny, nz;
      private double theta;
      private Matrix3D matrix;
  
      /***
       * Creates a rotate edit with no rotation.
       */
      public Rotate() {
          this(0, 0, 0, 1);
      }
  
      /***    
       * Creates a rotate edit with given rotation.
       */    
      public Rotate(double theta, double nx, double ny, double nz) {
          this(theta, nx, ny, nz, null, 0);
      }
  
      /***    
       * Creates a rotate edit with given rotation, animation shape and number of frames.
       */    
      public Rotate(double theta, double nx, double ny, double nz,
                    Shape shape, int frames) {
          super(shape, frames);
          matrix = Matrix3D.getRotateInstance(theta, nx, ny, nz);
          this.theta = theta;
          this.nx = nx;
          this.ny = ny;
          this.nz = nz;
      }
      
      public WiredEdit copy(RecordPlot plot) {
          WiredEdit copy = new Rotate(theta, nx, ny, nz, getShape(), getFrames());
          copy.setRecordPlot(plot);
          return copy;
      }
      
      protected Shape[] getShapes(Shape shape, int steps) {
          if ((shape == null) || (steps <= 1)) return null;
  
          // only for rotation over Z-axis        
          if ((nx != 0) || (ny != 0) || (nz != 1)) return null;
  
          Shape[] shapes = new Shape[steps];
  
          // calculate rotate increments
          double dtheta = theta/(steps-1);
  
          // calculate window offset
          double w = getRecordPlot().getWidth()/2.0;
          double h = getRecordPlot().getHeight()/2.0;
  
          // calculate steps
          for (int i=0; i<steps; i++) {
              AffineTransform transform = new AffineTransform();
              // rotate
              transform.rotate(-i*dtheta, w, h);
              // transform
              shapes[i] = transform.createTransformedShape(shape);
          }
          return shapes;
      }
  
      public Shape createTransformedShape(Component component, Shape shape) {
          // only for rotation over Z-axis        
          if ((nx != 0) || (ny != 0) || (nz != 1)) return null;
  
          double w = component.getWidth()/2.0;
         double h = component.getHeight()/2.0;
 
         AffineTransform transform = new AffineTransform();
         transform.rotate(-theta, w, h);
         return transform.createTransformedShape(shape);
     }
 
     public String getPresentationName() {
         double[] n = new double[3];
         double theta = matrix.getRotation(n);
         return toString()+" "+format.format(Math.toDegrees(theta))+" degrees over ("+format.format(n[0])+", "+format.format(n[1])+", "+format.format(n[2])+")";
     }
     
     public String toString() {
         return "Rotate";
     }
 
     public boolean addEdit(UndoableEdit edit) {
         if (edit instanceof Rotate) {
             Rotate rotate = (Rotate)edit;
             matrix.preConcatenate(rotate.matrix);
             // orthonormalize to keep matrix from skewing...
             matrix = matrix.createOrthonormalized();
             // copy the matrix into the edit
             rotate.matrix = matrix;
             
             // we return false to keep the single rotations stacked up.            
             return false;
         }
         return false;
     }
 
     public boolean isSupportedBy(GraphicsPanel p) {
         return p.supports(Rotateable2D.class) || p.supports(Rotateable3D.class);
     }
 
     protected void redoEdit() {
         GraphicsPanel panel = getRecordPlot().getGraphicsPanel();
         Rotateable3D rotateable3D = (Rotateable3D)panel.getFeature(Rotateable3D.class);
         if (rotateable3D != null) {        
             rotateable3D.rotate(theta, nx, ny, nz);          
         } else {
             Rotateable2D rotateable2D = (Rotateable2D)panel.getFeature(Rotateable2D.class);
             if (rotateable2D == null) {
                 System.err.println("Could not redo: "+this);
                 return;
             }
             // FIXME, WIRED-224 theta may not be correct...
             rotateable2D.rotate(theta);
         }
         getRecordPlot().repaint();
         logger.finer(toString());
     }
 
     protected void undoEdit() {
         GraphicsPanel panel = getRecordPlot().getGraphicsPanel();
         Rotateable3D rotateable3D = (Rotateable3D)panel.getFeature(Rotateable3D.class);
         if (rotateable3D != null) {        
             rotateable3D.rotate(-theta, nx, ny, nz);          
         } else {
             Rotateable2D rotateable2D = (Rotateable2D)panel.getFeature(Rotateable2D.class);
             if (rotateable2D == null) {
                 System.err.println("Could not undo: "+this);
                 return;
             }
             // FIXME, WIRED-224 theta may not be correct...
             rotateable2D.rotate(-theta);
         }
         getRecordPlot().repaint();
         logger.finer(toString());
     }
 }