/*
Copyright 2001 by Ralph Hartley
This software is licenced under the terms of the
Gnu Public Licence
*/
import java.awt.geom.*;
import java.awt.Graphics2D;
import javax.swing.*;
import java.util.*;

public abstract class Sub extends Symbol implements DragableSymbol,Aligner {

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

  static double MINR = 2;

  public ViewTransform relativepos = null;// obsolete 1/27/00 new ViewTransform(ViewTransform.PREMULTIPLY);
  public PointSym anchorpoint = new PointSym();
  
  public SavableRectangle2D box;

  transient public ViewTransform pos = null;
  transient public Point2D[] corners;

  public double handley = 0;
  public double handlex = 0;

  transient Point2D origin = new Point2D.Double();

  transient boolean brandnew = true;
//  public boolean lockrotation = false;
  public boolean editaspect = false;
//  public boolean lockscale = false;
  public boolean editrotation = true;
  public boolean editscale = true;
  public boolean showcorners = true;
//  public double scale = 1.0;
//  public double rotation = 0.0;
  public boolean sizewidth = true;

  public double subaspect = 1;
  public Size size = Size.none;

  transient boolean located = false;

  public void copy(Sub that) {
    handley = that.handley;
    handlex = that.handlex;

    editaspect = that.editaspect;
    editrotation = that.editrotation;
    editscale = that.editscale;
    showcorners = that.showcorners;
    sizewidth = that.sizewidth;

    subaspect = that.subaspect;
    size = that.size;
  }

  public Sub(){
    anchorpoint.getAlignTransform().addAlignmentListener(this);
  }

  public Sub(Point2D where,View view,Object arg) {
    anchorpoint.getAlignTransform().addAlignmentListener(this);
    if (arg instanceof Rectangle2D) {
      located=false;
      box = new SavableRectangle2D((Rectangle2D)arg);
    }
  }

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

  public void alignmentChanged(){
    located = false;
  }

//  transient JCheckBox rotlockf=null;
//  transient JCheckBox scalelockf=null;
  transient JRadioButton widthf=null;
  transient JRadioButton heightf=null;
  transient JComboBox sizefield=null;
//  transient PrefTrans trans=null;
  transient JComboBox editmodef = null;

  transient JRadioButton topf=null;
  transient JRadioButton botf=null;
  transient JRadioButton leftf=null;
  transient JRadioButton rightf=null;

  /**
   *Get the edit modes that are supported.
   */
  protected Vector getEditModes() {
    Vector res = new Vector();
    res.add("Translate");
    res.add("Rotate");
//    if (size==null || size.equals(Size.none)) {
      res.add("Scale");
      res.add("Scale & Rotate");
//    }
    return(res);
  }

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

  public void getPropertyEdit(Object[] edits,int slot,Set sub,Symbol parent) {
    located=false;
    locate();
    JPanel res = new JPanel();
    edits[slot] = res;
    ((java.awt.Component)edits[slot]).setName("Group");
    res.setLayout(new BoxLayout(res,BoxLayout.Y_AXIS));

    JPanel row = new JPanel();
    row.setLayout(new BoxLayout(row,BoxLayout.X_AXIS));

    Object[] editmodes = getEditModes().toArray();
    editmodef = new JComboBox(editmodes);
    for (int i=0;i<editmodes.length;i++)
      if ((editscale || ((String)editmodes[i]).indexOf("Scale")<0) &&
          (editrotation || ((String)editmodes[i]).indexOf("Rotate")<0) &&
          (editaspect || ((String)editmodes[i]).indexOf("Aspect")<0))
        editmodef.setSelectedIndex(i);

    JPanel modebox = new JPanel();
    modebox.add(new JLabel("Edit Mode"));
    modebox.add(editmodef);
    row.add(modebox);

//    rotlockf = new JCheckBox("Lock Rotation",lockrotation);
//    scalelockf = new JCheckBox("Lock Scale",lockscale);
//    row.add(rotlockf);
//    row.add(scalelockf);
    res.add(row);

//    trans = new PrefTrans(position,xorig,yorig);
//    res.add(trans.getBarePane(null));
    res.add(anchorpoint.pointPropertyEdit());

    row = new JPanel();
    row.setLayout(new BoxLayout(row,BoxLayout.X_AXIS));
    row.add(new JLabel("Handle:"));
    JPanel col = new JPanel();
    col.setLayout(new java.awt.GridLayout(1,6));
    ButtonGroup group = new ButtonGroup();

    topf = new JRadioButton("Top",handley==1);
    group.add(topf);
    col.add(topf);
    JRadioButton midf = new JRadioButton("Mid",handley==0);
    group.add(midf);
    col.add(midf);
    botf = new JRadioButton("Bottom",handley==-11);
    group.add(botf);
    col.add(botf);

    group = new ButtonGroup();
    leftf = new JRadioButton("Left",handlex==-1);
    group.add(leftf);
    col.add(leftf);
    midf = new JRadioButton("Mid",handlex==0);
    group.add(midf);
    col.add(midf);
    rightf = new JRadioButton("Right",handlex==1);
    group.add(rightf);
    col.add(rightf);

    row.add(col);
    res.add(row);    

    row = new JPanel();
    row.setLayout(new BoxLayout(row,BoxLayout.X_AXIS));
    widthf = new JRadioButton("Width",sizewidth);
    heightf = new JRadioButton("Height",!sizewidth);
    
    row.add(widthf);
    row.add(heightf);

    group = new ButtonGroup();
    group.add(widthf);
    group.add(heightf);

    row.add(new JLabel("Size "));
    sizefield = new JComboBox(Size.getAll(Size.class));
    sizefield.setSelectedItem(size);
    row.add(sizefield);

    res.add(row);

    super.getPropertyEdit(edits,slot-1,sub,parent);
  }

  public void acceptPropertyEdit() {
    if (widthf!=null) {
      String editmode = (String)editmodef.getSelectedItem();
      editscale = editmode.indexOf("Scale")>=0;
      editrotation = editmode.indexOf("Rotate")>=0;
      editaspect = editmode.indexOf("Aspect")>=0;

//      lockrotation = rotlockf.isSelected();
//      lockscale = scalelockf.isSelected();

      if (topf.isSelected()) handley = 1;
      else if (botf.isSelected()) handley = -1;
      else handley = 0;

      if (leftf.isSelected()) handlex = -1;
      else if (rightf.isSelected()) handlex = 1;
      else handlex = 0;

      sizewidth = widthf.isSelected();
      size = (Size)sizefield.getSelectedItem();
      if (size!=null && !size.equals(Size.none)) editscale = false;
      anchorpoint.acceptPropertyEdit();
//      trans.save();
      clear();
    }
    super.acceptPropertyEdit();
    located = false;
    reshape();
//    positionAnchor();
  }

  void clear() {
    editmodef = null;
    sizefield = null;
//    rotlockf = null;
//    scalelockf = null;
    widthf = null;
    heightf = null;
    topf = null;
    botf = null;
    leftf = null;
    rightf = null;
//    trans=null;
  }

  public void abandonPropertyEdit() {
    clear();
    anchorpoint.abandonPropertyEdit();
    super.abandonPropertyEdit();
  }

  void init(Point2D where,View view) {
    anchorpoint.position.setLocation(where);
    located=false;

    locate();
  }

  public ViewTransform getAlignTransform() {
    locate();
    return(anchorpoint.position);
  }

//  static boolean originpre = true;   //debug only

  public void locate() {
    if (located) return;
    located = true;

    if (box==null) {
      box = new SavableRectangle2D(-0.5,-0.5,1,1);
      reshape();
    }

    origin = new Point2D.Double(box.getX()+(handlex+1)*box.getWidth()/2,
        			box.getY()+(handley+1)*box.getHeight()/2);

    if (pos==null) pos = new ViewTransform();

    pos.setToTranslation(-origin.getX(),-origin.getY());
//    if (originpre)
    pos.preConcatenate(anchorpoint.position);
//    else
//      pos.concatenate(anchorpoint.position);

    if (corners==null) {
      corners = new Point2D.Double[4];
      for (int i=0;i<4;i++) corners[i] = new Point2D.Double();
    }

    corners[0].setLocation(box.getMinX(),box.getMinY());
    corners[1].setLocation(box.getMaxX(),box.getMinY());
    corners[2].setLocation(box.getMaxX(),box.getMaxY());
    corners[3].setLocation(box.getMinX(),box.getMaxY());

    for (int i=0;i<4;i++) pos.transform(corners[i],corners[i]);

//    System.out.println("this = "+this+" located at "+pos);
  }

//  void positionAnchor() {
//    anchorpoint.position.setLocation(xorig,yorig);
//    anchorpoint.position.preConcatenate(position);
//    position.transform(anchorpoint.position,anchorpoint.position);
//  }

  private void readObject(java.io.ObjectInputStream stream)
    throws java.io.IOException,java.lang.ClassNotFoundException {
    stream.defaultReadObject();
    brandnew = false;

    if (relativepos!=null) {
      anchorpoint.position = relativepos;
      relativepos = null;
    }

    if ((this instanceof Page) &&
        ((Page)this).aspect != -1 &&
        ((Page)this).aspect != 0) {
      subaspect = ((Page)this).aspect;
      ((Page)this).aspect = -1;
    }

    if (subaspect==0)
      subaspect = 1.0;

    if (size==null) size=Size.none;

    located = false;
  }

  public Rectangle2D getBounds(AffineTransform trans) {
    locate();

    Point2D.Double corn = new Point2D.Double();
    trans.transform(corners[0],corn);;
    Point2D.Double min = (Point2D.Double)corn.clone();
    Point2D.Double max = (Point2D.Double)corn.clone();

    for (int i=1;i<4;i++) {
      trans.transform(corners[i],corn);;
      if (corn.x<min.x) min.x = corn.x;
      if (corn.y<min.y) min.y = corn.y;
      if (corn.x>max.x) max.x = corn.x;
      if (corn.y>max.y) max.y = corn.y;
    }
    return(new Rectangle2D.Double(min.x,min.y,max.x-min.x,max.y-min.y));
  }

  public java.awt.Shape getShape(AffineTransform trans) {
    locate();

    return(trans.createTransformedShape(pos.createTransformedShape(box)));
  }

  transient double csize = 0;

  public void checkSize(View view) {
    if (size !=null && size!=Size.none) {
      if (origin==null) locate();
      csize = getScale(size,view);
      if (csize!=0) anchorpoint.position.setScale(csize/view.scale,0,0);
      located = false;
    }
  }

  public void paint(View view) {
    if (!view.visible.isMember(this)) return;

    checkSize(view);
    if (csize==0) return;

    locate();
    view.push(pos);
//    if (lockrotation) // && ((position.angle + view.angle)!= rotation)) {
//      view.setRotation(anchorpoint.position.angle - view.angle,
//        	       origin.getX(),origin.getY());


//    if (lockscale) //&& position.scale * view.scale!= scale) {
//      view.setScale(anchorpoint.position.scale/view.scale,
//        	    origin.getX(),origin.getY());

    paintContents(view);
    view.pop();
  }

  public double getScale(Size size,View view) {
//    System.out.println(" size = "+size);
//    System.out.println(" view.mapscale = "+view.mapscale);
//    System.out.println(" width = "+box.getWidth());
//    System.out.println(" height = "+box.getHeight());
//    System.out.println("res = "+size.getSize(view.mapscale)/(sizewidth?box.getWidth():box.getHeight()));
    return(size.getSize(view.mapscale)/(sizewidth?box.getWidth():box.getHeight()));
  }

  public abstract void paintContents(View view);

  Point2D getPolar(Point2D p,View v) {
    double r = anchorpoint.position.distance(p);
//    if (r<(MINR/v.scale)) return(new Point2D.Double(MINR/v.scale,0));
    if (r==0) return(new Point2D.Double(MINR/v.scale,0));
    else return(new Point2D.Double(r,-Math.atan2(p.getX()-anchorpoint.position.getTranslateX(),
        					 p.getY()-anchorpoint.position.getTranslateY())));
  }

  public boolean selectProbe(Point2D pos,View view){
//    System.out.println("this = "+this+" probe at "+anchorpoint.position+" where = "+pos);
    brandnew = false;
    if (anchorpoint.selectProbe(pos,view)) return(true);
    double BOXSIZE = Size.handle.getSize(view.mapscale);
    for (int i=0;i<4;i++)
      if (pos.distance(corners[i].getX(),corners[i].getY())<BOXSIZE/view.scale) return(true);
//    System.out.println("this = "+this+" probe false");
    return(false);
  }

  transient boolean cornerdrag = false;
  transient Point2D dragpos = null;
  
  public void startDrag(int command,Point2D where,View view){
//    System.out.println("this = "+this+" start drag at "+anchorpoint.position+" where = "+where);
    cornerdrag = false;
    int i=4;

    if (brandnew) {
      checkSize(view);
      showSelected(view);
      where = corners[0];
    }

    if ((brandnew || !anchorpoint.selectProbe(where,view)) && (editrotation || editscale || editaspect))
      for (i=0;i<4;i++)
        if (where.distance(corners[i].getX(),corners[i].getY())<Size.handle.getSize(view.mapscale)/view.scale ||
            brandnew) {
          cornerdrag = true;
          if (editaspect)
            dragpos = new Point2D.Double(where.getX()-anchorpoint.position.getTranslateX(),
        				 where.getY()-anchorpoint.position.getTranslateY());
          else {
            dragpos = getPolar(where,view);
          }
          break;
        }
    if (i==4) dragpos = where;
  }

  public void drag(int command,Point2D where,View view){
//    System.out.println("this = "+this+" drag at "+anchorpoint.position+" where = "+where);
    showSelected(view);
    located = false;
    if (cornerdrag) {
      Point2D newpos = null;
      if (editaspect) {
        double c,s;
        newpos = new Point2D.Double(where.getX()-anchorpoint.position.getTranslateX(),
        			    where.getY()-anchorpoint.position.getTranslateY());
        if (!sizewidth&& size!=null && !size.equals(Size.none)) {
          c = -Math.cos(/*view.angle*/-anchorpoint.position.angle);
          s =  Math.sin(/*view.angle*/-anchorpoint.position.angle);
          subaspect /= (c*newpos.getX()+s*newpos.getY())/(c*dragpos.getX()+s*dragpos.getY());
          anchorpoint.position.setScale(anchorpoint.position.scale*(c*newpos.getX()+s*newpos.getY())/
        				(c*dragpos.getX()+s*dragpos.getY()),0,0);//origin.getX(),origin.getY());
        }
        else {
          s = Math.cos(/*view.angle*/-anchorpoint.position.angle);
          c = Math.sin(/*view.angle*/-anchorpoint.position.angle);
          double fact;
          if (editscale) {
            fact = (-s*newpos.getX()+c*newpos.getY())/
              (-s*dragpos.getX()+c*dragpos.getY());
            anchorpoint.position.setScale(anchorpoint.position.scale*fact
        				  ,0,0);//origin.getX(),origin.getY());
          } else fact = 1.0;
          subaspect *= (c*newpos.getX()+s*newpos.getY())/(c*dragpos.getX()+s*dragpos.getY())/fact;
        }
        reshape();
      }
      else {
        newpos = getPolar(where,view);
          if (editscale)
            anchorpoint.position.setScale(anchorpoint.position.scale*newpos.getX()/dragpos.getX(),
        				  0,0);//origin.getX(),origin.getY());
          if (editrotation)
            anchorpoint.position.setRotation(anchorpoint.position.angle+newpos.getY()-dragpos.getY(),
        				     0,0);//origin.getX(),origin.getY());
      }
      dragpos=newpos;
    } else {
      anchorpoint.position.preConcatenate(new AffineTransform(1,0,0,1,
        						      where.getX()-dragpos.getX(),
        						      where.getY()-dragpos.getY()));
      dragpos=where;
    }
    showSelected(view);
  }

  public void endDrag(int comand,Point2D pos,View view){
    located=false;
//    System.out.println("this = "+this+" end-drag at "+pos);
    anchorpoint.position.notifyChange();
  }

  public void showSelected(View view) {
    int BOXSIZE = (int)Size.handle.getSize(view.mapscale);
    Point2D tpos = new Point2D.Double();
    Point2D cpos = new Point2D.Double();
    Graphics2D g;
    int arrows=0;
    double c=0,s=0;
    g = view.draw;
    locate();
    anchorpoint.position.transformOrigin(view.trans,cpos);
//    view.trans.transform(anchorpoint.position,cpos);
    g.drawRect((int)(cpos.getX()-BOXSIZE),(int)(cpos.getY()-BOXSIZE),2*BOXSIZE,2*BOXSIZE);
//    if (showcorners)
    for (int i=0;i<4;i++) {
      arrows = 0;
      view.trans.transform(corners[i],tpos);
      g.drawRect((int)(tpos.getX()-BOXSIZE),(int)(tpos.getY()-BOXSIZE),2*BOXSIZE,2*BOXSIZE);
      if (editaspect) {
        arrows = (editscale?2:1);
        if (!sizewidth&& size!=null && !size.equals(Size.none)) {
          c = Math.cos(-view.angle-anchorpoint.position.angle);
          s = Math.sin(-view.angle-anchorpoint.position.angle);
        }
        else {
          s = -Math.cos(view.angle-anchorpoint.position.angle);
          c = Math.sin(view.angle-anchorpoint.position.angle);
        }
      }
      else if (editrotation) {
        arrows = (editscale?2:1);
        c = tpos.getY()-cpos.getY();
        s = -(tpos.getX()-cpos.getX());
        double fact = Math.sqrt(c*c+s*s);
        c/=fact;
        s/=fact;
      }
      else if (editscale) {
        arrows = 1;
        s = tpos.getY()-cpos.getY();
        c = tpos.getX()-cpos.getX();
        double fact = Math.sqrt(c*c+s*s);
        c/=fact;
        s/=fact;
      }
      
      if (arrows>0) {
        g.drawLine((int)(tpos.getX()-BOXSIZE*c*2),(int)(tpos.getY()-BOXSIZE*s*2),
        	   (int)(tpos.getX()+BOXSIZE*c*2),(int)(tpos.getY()+BOXSIZE*s*2));
      }
      if (arrows>1) {
        g.drawLine((int)(tpos.getX()+BOXSIZE*s*2),(int)(tpos.getY()-BOXSIZE*c*2),
        	   (int)(tpos.getX()-BOXSIZE*s*2),(int)(tpos.getY()+BOXSIZE*c*2));
      }
    }
    
  }

  public void reshape() {
    double oldheight = box.getHeight();
    box.height = subaspect*box.getWidth();
    box.x = -box.getWidth()/2;
    box.y = -box.getHeight()/2;
    located = false;
//    getCenter();
  }

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

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