/*
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 javax.swing.*;
import java.awt.geom.*;

/**
 *A control point on a Curve.
 *Consists of a point and two tangent directions determined by guide points.
 */
public class Anchor extends PointSym implements DragableSymbol {

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

//  static int NONE = -3;
  /**Indicates smooth mode.
   *Where the guide points are slaved to each other so that the curve stays smooth*/

  static int SMOOTH = -2;

  /**Indicates that the anchor as a whole is selected.
   *As when the central point is clicked */
  static int ALL = -1;

  /**Indictes that the first guide point is selected. */
  static int GUIDE0 = 0;

  /**Indictes that the second guide point is selected. */
  static int GUIDE1 = 1;

  /** Indicates guide is valid but not guidelocal */
  static int GLOBAL = 0;

  /** Indicates guidelocal is valid but not guide */
  static int LOCAL = 1;

  /** Indicates guide and guidelocal are valid and consistant */
  static int CONSISTANT = 2;

  /**The two guide points.
   *must be transient because Point2D is not Serializable*/
  transient public Point2D[] guide = new Point2D[2];

  /**The two guide points in local coords.
   *must be transient because Point2D is not Serializable
   *Except for storage in a file, guide is derived from guidelocal */
  transient public Point2D[] guidelocal = new Point2D[2];
 
  /** Indicates which form of the guide point is official.
   * Posible values are LOCAL, GLOBAL, or CONSISTANT.
   * Before using guide points use guideUpdate() to make it CONSISTANT.
   */
  transient int guidestate = LOCAL;

//  transient double[] length = new double[2];
  /**If true, curve has a kink at this point. */
  boolean kink=false;

  /** The arrow head to draw at this point.
   */
  public Arrow arrow = null;

  /** Reverse the direction of the arrow?.
   */
  public boolean arrowreverse = false;

  /** The selection state of this anchor.
   * Possible values are SMOOTH, ALL, GUIDE0, and GUIDE1.
   */
  int selmode;

  /**Read the anchor and re-constitute its transient variables.
   *That is, its goude points. */
  private void readObject(java.io.ObjectInputStream stream)
      throws java.io.IOException,java.lang.ClassNotFoundException {
    stream.defaultReadObject();
    guide = new Point2D[2];
    guidelocal = new Point2D[2];
    guidelocal[0] = new Point2D.Double();
    guidelocal[1] = new Point2D.Double();
    guide[0] = new Point2D.Double(stream.readDouble(),stream.readDouble());
    guide[1] = new Point2D.Double(stream.readDouble(),stream.readDouble());
    guidestate = GLOBAL;
  }

  /**Writes the anchor and the positions of its guide points. */
  private void writeObject(java.io.ObjectOutputStream stream)
      throws java.io.IOException {
    stream.defaultWriteObject();
    guideUpdate();
    stream.writeDouble(guide[0].getX());
    stream.writeDouble(guide[0].getY());
    stream.writeDouble(guide[1].getX());
    stream.writeDouble(guide[1].getY());
  }

  /** Take notice of change in position,<br>
   * caused by alignment.
   */
  public void alignmentChanged() {
    guidestate = LOCAL;
  }

  Point2D.Double morphpos0 = null;
  Point2D.Double morphpos1 = null;

  public void prepareForSurveyUpdate(java.util.List segments) {
//    System.out.println("anchor prep");
//    if (true) return;
    guideUpdate();
    super.prepareForSurveyUpdate(segments);
    if (morphsegment!=null) {
      morphpos0 = new Point2D.Double();
      morphsegment.map.btrans(guide[0],morphpos0);
      morphpos1 = new Point2D.Double();
      morphsegment.map.btrans(guide[1],morphpos1);
    }
  }

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

    if (morphsegment!=null) {
      Point2D.Double res = new Point2D.Double();
      morphsegment.map.ftrans(morphpos0,res);
      guide[0]=res;
      morphpos0 = null;
      res = new Point2D.Double();
      morphsegment.map.ftrans(morphpos1,res);
      guide[1] = res;
      morphpos1 = null;
    }

    super.useSurveyUpdate();
    guidestate = GLOBAL;



/*
    guideUpdate();
    guidestate = GLOBAL;
    position.setTransform(1,0,position.getTranslateX(),position.getTranslateY());
    guideUpdate();
*/
  }

  /** sets the local and  global coords to match. 
   *Which is taken as primary depends on guidestate */
  public void guideUpdate() {
    if (guidestate==GLOBAL) {
      try {
        position.inverseTransform(guide[0],guidelocal[0]);
        position.inverseTransform(guide[1],guidelocal[1]);
      } catch (NoninvertibleTransformException ex) {
        ErrorLog.log("Internal error in guideUpdate");
        ErrorLog.exception(ex);
        return;
      }
    }
    else if (guidestate==LOCAL) {
      position.transform(guidelocal[0],guide[0]);
      position.transform(guidelocal[1],guide[1]);
    }
    guidestate=CONSISTANT;
  }

  /**Creates a new anchor at the specified location.
   *The new anchor will be in SMOOTH mode, and its guide points
   *will be at its central point (the place that was clicked) */
  public Anchor(Point2D where,View view,Object arg) {
    super(where,view,arg);
    guidelocal[0]= new Point2D.Double(0,0);
    guidelocal[1]= new Point2D.Double(0,0);
    guide[0]= (Point2D)position.getTranslation();
    guide[1]= (Point2D)position.getTranslation();
//    guide[0]= new Point2D.Double(0,0);
//    guide[1]= new Point2D.Double(0,0);
    guidestate = GLOBAL;
    selmode = SMOOTH;
  }
/*
  public void setAlignment(Alignment source,java.util.HashSet sub){
    guideUpdate();
    position.addAlignmentListener(this);
    position.setAlignment(source,null);     
    if (!position.hasAlignment()) 
      position.removeAlignee(this);
//    System.out.println("anchor = "+this);
//    position.listAlignees();
  }
*/

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

  public void getPropertyEdit(Object[] edits,int slot,java.util.Set sub, Symbol parent) {
    edits[slot] = anchorPropertyEdit();
//    ((Component)edits[slot]).setName("Arrow");
    super.getPropertyEdit(edits,slot-1,sub,parent);
  }

  transient JComboBox arrowfield;
  transient JCheckBox reversebox;

  java.awt.Container anchorPropertyEdit() {
    JPanel res = new JPanel();
    res.setName("Arrow");
    res.setLayout(new BoxLayout(res,BoxLayout.Y_AXIS));

    arrowfield = new JComboBox(Arrow.getAll(Arrow.class));
    arrowfield.setSelectedItem(arrow);
    res.add(arrowfield);
    reversebox = new JCheckBox("Reverse",arrowreverse);
    res.add(reversebox);

    return(res);
  }

  public void acceptPropertyEdit() {
    if (arrowfield!=null) {

      arrow = (Arrow)arrowfield.getSelectedItem();
      if (arrow==Arrow.none) arrow = null;
      arrowreverse = reversebox.isSelected();

      arrowfield = null;
      reversebox = null;
    }
    super.acceptPropertyEdit();
  }

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

  /**Determines if a mouse press selects this anchor.
   *If so remembers which part of the anchor was pressed (by setting selmode), so that
   *the same part can be dragged if needed*/
  public boolean selectProbe(Point2D where,View view){
    double BOXSIZE = Size.handle.getSize(view.mapscale);
    if (position.distance(where)<BOXSIZE/view.scale) {
      selmode = ALL;
      return(true);
    }
    guideUpdate();
    if (guide[0].distance(where)<BOXSIZE/view.scale) {
      selmode=GUIDE0;
      return(true);
    }
    if (guide[1].distance(where)<BOXSIZE/view.scale) {
      selmode=GUIDE1;
      return(true);
    }
    return(false);
  }

  /**Start dragging this Anchor. */
  public void startDrag(int command,Point2D where,View view) {
    if ((command&CompPane.SMOOTH)!=0) {
      if (selmode== ALL && kink) {
        selmode = SMOOTH;
        kink = false;
      }
      else if (selmode>=0) kink = true;
    }
    dragpoint = where;
  }

  /**Drag the Anchor.
   *Which part will actually move depends on the valeue of selmode*/
  public void drag(int command,Point2D where,View view) {
    showSelected(view);
    if (selmode==SMOOTH) {   //smoothing a corner
      guide[1].setLocation(where.getX()-dragpoint.getX()+guide[1].getX(),
        		   where.getY()-dragpoint.getY()+guide[1].getY());
      guide[0].setLocation(2*position.getTranslateX()-guide[1].getX(),
        		   2*position.getTranslateY()-guide[1].getY());
      guidestate = GLOBAL;
    }
    else if (selmode==ALL) {
      guidestate = LOCAL;
      position.setLocation(position.getTranslateX()+(where.getX()-dragpoint.getX())/position.scale,
        	           position.getTranslateY()+(where.getY()-dragpoint.getY())/position.scale);
    }
    else if (selmode>=GUIDE0) {
      Point2D drager = guide[selmode-GUIDE0];
      Point2D dragee = guide[1-(selmode-GUIDE0)];
      double length1 = position.distance(dragee);
      drager.setLocation(drager.getX()+where.getX()-dragpoint.getX(),
        		 drager.getY()+where.getY()-dragpoint.getY());
      double length0 = position.distance(drager);
      if (!kink)
        dragee.setLocation(position.getTranslateX()+length1*(position.getTranslateX()-drager.getX())/length0,
        		   position.getTranslateY()+length1*(position.getTranslateY()-drager.getY())/length0);
      guidestate = GLOBAL;
    }
    dragpoint = where;
    showSelected(view);
  }

  /**
   *Ends drag.
   *Alerts alignees that may depend on this point.
   */
  public void endDrag(int comand,Point2D pos,View view){
    position.notifyChange();
  }


  /**
   *Draw the drag box of the Anchor as selected.
   *The box is shown filled with its guide points. Draw the guide point that can be
   *dragged (if any) as a filled circle.
   */
  public void showSelected(View view) {
    guideUpdate();

    Point2D tpos = new Point2D.Double();
    Point2D tguide = new Point2D.Double();

    int BOXSIZE = (int)Size.handle.getSize(view.mapscale);

    position.transformOrigin(view.trans,tpos);
//    view.trans.transform(position,tpos);
    view.draw.fillRect((int)tpos.getX()-BOXSIZE,(int)tpos.getY()-BOXSIZE,2*BOXSIZE,2*BOXSIZE);

    for (int i=0;i<2;i++) {
      view.trans.transform(guide[i],tguide);

      view.draw.drawLine((int)tpos.getX(),(int)tpos.getY(),(int)tguide.getX(),(int)tguide.getY());

      if (selmode==i)
        view.draw.fillOval((int)tguide.getX()-BOXSIZE,(int)tguide.getY()-BOXSIZE,2*BOXSIZE,2*BOXSIZE);
      else
        view.draw.drawOval((int)tguide.getX()-BOXSIZE,(int)tguide.getY()-BOXSIZE,2*BOXSIZE,2*BOXSIZE);
    }
  }

  /**Paint the Anchor.
   *The only visible part of an anchor is it's drag box. When not
   *selected anchors are only visible by their effect on the curve*/
  public void paint(View view) {
    guideUpdate();
    if (!view.visible.isMember(this)) return;
    int BOXSIZE = (int)Size.handle.getSize(view.mapscale);
    Point2D tpos = new Point2D.Double();
    position.transformOrigin(view.trans,tpos);
//    view.trans.transform(position,tpos);
    view.draw.drawRect((int)tpos.getX()-BOXSIZE,(int)tpos.getY()-BOXSIZE,2*BOXSIZE,2*BOXSIZE);
    view.trans.transform(guide[0],tpos);
    view.draw.drawOval((int)tpos.getX()-BOXSIZE,(int)tpos.getY()-BOXSIZE,2*BOXSIZE,2*BOXSIZE);
    view.trans.transform(guide[1],tpos);
    view.draw.drawOval((int)tpos.getX()-BOXSIZE,(int)tpos.getY()-BOXSIZE,2*BOXSIZE,2*BOXSIZE);
  }
}