/*
Copyright 2000 by Ralph Hartley
This software is licenced under the terms of the
Gnu Public Licence
*/
import java.awt.event.*;
import java.awt.*;
import java.util.*;
import java.awt.geom.*;
import javax.swing.*;
public class PointSym extends Symbol implements Aligner {

  private static final long serialVersionUID = Version.getSUID();

//  transient Point2D pos;
  boolean valid = false;
  public ViewTransform position = new ViewTransform(ViewTransform.PREMULTIPLY);

  public PointSym(){
  }

  public PointSym(Point2D pos,View view,Object arg) {
    this.position = new ViewTransform(pos);
    position.addAlignmentListener(this);
  }

  public ViewTransform defaultPosition() {
    return(null);
  }

  public ViewTransform getAlignTransform() {
    return(position);
  }

  private void readObject(java.io.ObjectInputStream stream)
      throws java.io.IOException,java.lang.ClassNotFoundException {
    stream.defaultReadObject();
    if (position == null) // up compat 2/19/01
      position = new ViewTransform(stream.readDouble(),stream.readDouble());
    position.addAlignmentListener(this);
  }

  transient PrefTrans trans=null;

  public int getLevel() {return(super.getLevel()+1);}

  public void getPropertyEdit(Object[] edits,int slot,java.util.Set sub,Symbol parent) {
    edits[slot] = pointPropertyEdit();
//  ((Component)edits[slot]).setName("Point");
    super.getPropertyEdit(edits,slot-1,sub,parent);
  }
  
  java.awt.Container pointPropertyEdit() {
    trans = new PrefTrans(position);
    java.awt.Container res = trans.getBarePane(null);
    res.setName("point");
    return(res);
  }

  public void acceptPropertyEdit() {
    if (trans!=null) {
      trans.save();
      trans = null;
      position.notifyChange();
    }
    super.acceptPropertyEdit();
  }

  public void abandonPropertyEdit() {
    trans = null;
    super.abandonPropertyEdit();
  }

  public void alignmentChanged() {}

  public transient Segment morphsegment = null;

  transient Point2D morphpos = null;

//  transient AffineTransform morphtrans = null;
//  static int upcount = 0;

  public void prepareForSurveyUpdate(java.util.List segments) {
//    System.out.println("pointsym prep");
//    if (true) return;
    if (segments==null) return;

    Point2D pos = position.getTranslation();
    Point2D.Double imagepos = new Point2D.Double();

//    morphsegment = null;

    for (Iterator it = segments.iterator(); morphsegment==null && it.hasNext();) {
      Segment seg = (Segment)it.next();
//      System.out.println("Position = "+position);
//      System.out.println("Pos = "+pos);
      seg.map.btrans(pos,imagepos);

      if (seg.boundary.contains(imagepos)) {

        morphsegment = seg;
        morphpos = imagepos;
        imagepos = new Point2D.Double();
        if (Curve.debug&& morphsegment.name.compareTo("d17")==0)
          System.out.println("seg = "+seg.name+" old pos = "+pos+" morphpos = "+morphpos);
//        double[][] grad = new double[2][2];
      
//        seg.map.getGrad(grad,pos.getX(),pos.getY());
        
//      System.out.println("grad = [ "+grad[0][0]+" , "+grad[0][1]+" , "+grad[1][0]+" , "+grad[1][1]+" ]");

//        morphtrans = new AffineTransform(grad[0][0],grad[1][0],grad[0][1],grad[1][1],0,0);
//        morphtrans.preConcatenate(position);

//      System.out.println(" morphtrans = "+morphtrans);
      
      }
    }

//    upcount = 0;
  }

  /**
   *Called when the survey has changed.<br>
   */
  public void useSurveyUpdate() {
//    if (true) return;

    if (morphsegment == null) return;

    morphsegment.map.solve();

    Point2D.Double pos = new Point2D.Double();
    morphsegment.map.ftrans(morphpos,pos);

    if (Curve.debug && morphsegment.name.compareTo("d17")==0)
      System.out.println("seg = "+morphsegment.name+"morphpos = "+morphpos+" newpos = "+pos);

/*
    double[][] grad = new double[2][2];
    
    morphsegment.map.getGrad(grad,pos.getX(),pos.getY());

//    System.out.println("grad = [ "+grad[0][0]+" , "+grad[0][1]+" , "+grad[1][0]+" , "+grad[1][1]+" ]");
      
    AffineTransform trans = new AffineTransform(grad[0][0],grad[1][0],grad[0][1],grad[1][1],0,0);

    try {
      trans = trans.createInverse();
    } catch (NoninvertibleTransformException ex) {
      showUpdateError(morphsegment,"noninvertible matrix");
      return;
    } 

    morphtrans.concatenate(trans);
    
    if (!position.setTrans(morphtrans,pos))
      showUpdateError(morphsegment,"couldn't orthogonalize");
*/

    position.setLocation(pos.getX(),pos.getY());
//    System.out.println("new pos = "+position);

//    morphtrans = null;
    morphsegment = null;
  }

/*
  public void showUpdateError(Segment seg,String str) {
    if (upcount==0)
      ErrorLog.log("Trouble tracking survey update\n"+
        	   "Problem ="+str+
        	   "anchor = "+this+" segment = "+seg+"\n"+
        	   "The map symbol was not updated\n"+
        	   "This warning will only appear once/update");
    upcount++;
  }
*/
  public boolean selectProbe(Point2D where,View view){
    return(position.distance(where)<Size.handle.getSize(view.mapscale)/view.scale);
  }
  
  public Rectangle2D getBounds(AffineTransform trans) {
    Point2D tpos = position.getTranslation();
    trans.transform(tpos,tpos);
    return(new Rectangle2D.Double(tpos.getX(),tpos.getY(),0,0));
  }

  public void showSelected(View view) {
    int BOXSIZE = (int)Size.handle.getSize(view.mapscale);
    Point2D tpos = position.getTranslation();
    view.trans.transform(tpos,tpos);
    view.draw.fillRect((int)tpos.getX()-BOXSIZE,(int)tpos.getY()-BOXSIZE,2*BOXSIZE,2*BOXSIZE);
  }

  transient Point2D dragpoint = null;

  public void startDrag(int command,Point2D where,View view) {
    dragpoint = where;//position.getTranslation();
  }

  public void drag(int command,Point2D where,View view) {
    showSelected(view);
    position.setLocation(position.getTranslateX()+where.getX()-dragpoint.getX(),
        		 position.getTranslateY()+where.getY()-dragpoint.getY());
    dragpoint = where;
    showSelected(view);
  }

  public void paint(View view) {
    if (!view.visible.isMember(this)) return;
    int BOXSIZE = (int)Size.handle.getSize(view.mapscale);
    Point2D tpos = position.getTranslation();
    view.trans.transform(tpos,tpos);
    view.draw.drawRect((int)tpos.getX()-BOXSIZE,(int)tpos.getY()-BOXSIZE,2*BOXSIZE,2*BOXSIZE);
  }

  public void showAlignee(View view) {
    position.showAlignee(view);
  }

  public Point2D showAligner(View view) {
    return(position.showAligner(view));
  }
}