//*****************************************************************************
//
// Beenish Chaudry, Geetika Tewari, Elif Tosun and
// Ileana Streinu
//
// Summer 1999, Fall 1999, Spring 2000
//
//*****************************************************************************
//
//   PointSet.java
//
//*****************************************************************************


import java.awt.*;
import java.awt.event.*;
import java.lang.*;
import java.io.*;
import java.util.*;

public class PointSet{

  LList ptList;  //stores the points drawn on the point canvas in a list
 
  // In addition, to control the relative coordinates of the points
  // we need the frame of reference: origin, unit length and orientation

  Point or; // origin coordinates in pixels
  Rational unitL; //Unit length in pixels
  boolean wOrient; //variable for orientation of y-axis

  // for labelling in a standard way

  int counterP; // counter, incremented for each new point added
                // to get the point id, linsert

  // control

  FramePoint bf;  // the parent frame, where some global variables are stored
  Vector observers;  //observers are: java console, infoframe


  //********************
  //
  //  Constructor 
  //
  //********************

  public PointSet(FramePoint bff) {

    ptList = Constants.nullCell;

    or = Constants.ctOrigin;
    unitL = new Rational(1,1);
    wOrient = false;
    counterP = 1; // ??? make it: initPtId();

    bf = bff;
    observers = new Vector();
    
  }
  
  //********************************************************
  //
  //  Reset
  //
  // called in: PointMenuBar, when New menu option is chosen
  //
  //********************************************************
  
  public void Reset() {
    
    ptList = Constants.nullCell;
    counterP = 1;  // ??? make it: initPtId();

    notifyObservers();
    
  }//end Reset
  
  
  //*******************************
  //
  //  AddPoint
  //
  //******************************
  
  public LList addPoint(PointObj p) {

    //  compute the relative coordinates
    p.AbsToRel(or, wOrient, unitL);
    p.linsert = counterP++; // make it: bf.newPtId(); ???

    // update xcoord label - Ileana ???
    
    p.InitLocLabelP();

    // compute hooks for drawing line and use them to initialize
    // label and coordinate location for dual line

    p.ComputeLineHooks(bf.width, bf.height, or, wOrient, unitL, bf.lf.duality, 
		     p.hookN, p.hookS); 

    p.LocLabelL.x = p.hookN.x;
    p.LocLabelL.y = p.hookN.y + 20;

    p.LocEqL.x = p.hookS.x;
    p.LocEqL.y = p.hookS.y - 20;


    // finally,  insert
 
    ptList = ptList.InsertFront(p);
    notifyObservers(); 
    return(ptList);
  }
  
  //*******************************
  //
  //  DeletePoint
  //
  //******************************

  public void DeletePoint(PointObj p) {
    
    if(ptList != Constants.nullCell)
      ptList = ptList.LDelete(p);
    // update labels of other points - Ileana ???
    notifyObservers(); 
  }

  //*******************************
  //
  //  LSearch
  //
  //******************************

  public PointObj LSearch(PointObj p) {
  
    LList temp = ptList.LSearch(p);
    if (temp != null)
      return(temp.data);
    return(null);
  }


  //********************************************
  //
  //  MovePoint
  //  use the info in PointSet to update the
  //  relative coordinates and labels of a point
  //
  //*********************************************

  public void MovePoint(PointObj p) {

    // update relative coordinates
    p.AbsToRel(or, wOrient, unitL);
    // p.UpdateLocLabels(bf, or, wOrient, unitL); ?? work on - maybe for lines
    p.UpdateLabel();
      // update labels of the moved point, too !!! -- ????

    p.UpdateHooks(bf); 

    notifyObservers(); 
  }




  //***********************************************
  //
  // MoveSelPoints
  //
  // move the selected points using arrow keys
  // as given by the parameter key
  //
  //***********************************************


public void MoveSelPoints(int key)
  {
    
    LList ptr = ptList; 
    
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  {
	    ptr.data.MoveSelPoint(bf, key, or, wOrient, unitL);
	  }
	ptr = ptr.next;
      }// end while
    

    notifyObservers();     
    
  }// end MoveSelPoints



  //***********************
  //
  // SelectAll
  //
  // select all points
  //
  //***********************

public void SelectAll()
  {
    
    LList ptr = ptList; 
    
    while (ptr != Constants.nullCell)
      {
	ptr.data.selected = StateSelect.yes;
	ptr = ptr.next;    
      }
    notifyObservers();     
    
  }// end SelectAll



  //***********************
  //
  // DeselectAll
  //
  // deselect all points
  //
  //***********************

public void DeselectAll()
  {
    
    LList ptr = ptList; 
    
    while (ptr != Constants.nullCell)
      {
	ptr.data.selected = StateSelect.not;
	ptr = ptr.next;
      }
    notifyObservers();     
    
  }// end DeselectAll
  

  //****************************************
  //
  // *****  points  ********
  //
  // SetShapeSelected
  // SetFillSelected
  // SetFillColorSelected
  // SetContourSelected
  // SetContColorSelected  
  // SetVisibleSelected
  // SetCoordSelected
  // SetEqSelected
  //  
  // TranslateSelected
  // TranslateLPSelected
  // TranslateCPSelected
  // TranslateLLSelected
  // TranslateELSelected
  //
  // DeleteSelected
  //
  //
  // set a property for all selected points
  //
  //*****************************************
  
  public void SetShapeSelected(int shape)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  ptr.data.appearanceP.shape = shape;
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end SetShapeSelected

  public void SetFillSelected(int fill)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  ptr.data.appearanceP.fill = fill;
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end SetFillSelected
  
  public void SetFillColorSelected(Color fillcolor)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  ptr.data.appearanceP.fillcolor = fillcolor;
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end SetFillColorSelected
  
  public void SetContourSelected(int contour)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  ptr.data.appearanceP.contour = contour;
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end SetContourSelected
  
  
  public void SetContourColorSelected(Color contcolor)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  ptr.data.appearanceP.contcolor = contcolor;
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end SetContourColorSelected
  
  public void SetVisibleSelected(int visible)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  ptr.data.appearanceP.visible = visible;
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end SetVisibleSelected


  public void SetCoordSelected(int coord)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  ptr.data.appearanceP.wCoord = coord;
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end SetCoordSelected

  public void SetEqSelected(int eq)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  ptr.data.appearanceL.equation = eq;
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end SetEqSelected



  public void TranslateSelected(Point displacement)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  {
	    ptr.data.x +=displacement.x;
	    ptr.data.y +=displacement.y;
	    // update relative coordinates
	    ptr.data.AbsToRel(or, wOrient, unitL);
	    ptr.data.UpdateLabel();
	    ptr.data.UpdateHooks(bf); 
	  }
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end TranslateSelected


  public void TranslateLPSelected(Point displacement)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  {
	    ptr.data.LocLabelP.x = displacement.x;
	    ptr.data.LocLabelP.y = displacement.y;
	  }
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end TranslateLPSelected



  public void TranslateCPSelected(Point displacement)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  {
	    ptr.data.LocCoordP.x =displacement.x;
	    ptr.data.LocCoordP.y =displacement.y;
	  }
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end TranslateCPSelected



  public void TranslateLLSelected(Point displacement)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  {
	    ptr.data.LocLabelL.x =displacement.x;
	    ptr.data.LocLabelL.y =displacement.y;
	  }
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end TranslateLLSelected


  public void TranslateELSelected(Point displacement)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  {
	    ptr.data.LocEqL.x = displacement.x;
	    ptr.data.LocEqL.y = displacement.y;
	  }
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end TranslateELSelected





  public void DeleteSelected()
  {
    LList ptr = ptList; LList prev = ptList;
    LList first = ptList;
    
    // special tratement delete first element
    
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  {	  
	    ptr = ptr.next;
	    first = ptr;
	    prev = ptr;
	  }
	else 
	  {
	    ptr = Constants.nullCell;
	  }
      }// end special treatment delete leading cells

    if (first != Constants.nullCell) // at least one non-selected element
      {
	ptr = first.next;
	while (ptr != Constants.nullCell)
	  {
	    if (ptr.data.selected == StateSelect.yes)
	      {	     
		prev.next = ptr.next;
	      }
	    else
	      {
		prev = ptr;
	      }
	    ptr = ptr.next;
	  }
      }
    
    // update labels ???
    ptList = first;
    notifyObservers();

  }// end DeleteSelected
  


  //****************************************
  //
  // **** lines *******
  //
  // SetStyleSelected
  // SetLineColorSelected
  // SetLineThickness
  // SetLineClippedSelected
  //
  //
  //
  // set a property for all dual lines, selected via points
  //
  //*****************************************
  
  public void SetStyleSelected(int style)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  ptr.data.appearanceL.style = style;
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end SetStyleSelected


  public void SetLineColorSelected(Color color)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  ptr.data.appearanceL.color = color;
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end SetLineColorSelected

  public void SetLineThicknessSelected(int thickness)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  ptr.data.appearanceL.thickness = thickness;
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end SetLineThicknessSelected


  public void SetLineClippedSelected(int clip)
  {
    LList ptr = ptList; 
    while (ptr != Constants.nullCell)
      {
	if (ptr.data.selected == StateSelect.yes)
	  ptr.data.appearanceL.clipped = clip;
	ptr = ptr.next;
      }
    notifyObservers();     
  }// end SetLineClippedSelected


  
  //*******************************
  //
  //  AbsToRel
  //
  // recompute the relative coordinates
  // for all points
  //
  //******************************
  
  public void AbsToRel() 
  {
    for (LList ptr = ptList; ptr != Constants.nullCell; ptr = ptr.next) 
      ptr.data.AbsToRel(or, wOrient, unitL);
  } // end AbsToRel
  

  //*******************************
  //
  //  UpdateHooks
  //
  // recompute the hooks for dual lines
  //
  //******************************
  
  public void UpdateHooks(FramePoint bf) 
  {
    for (LList ptr = ptList; ptr != Constants.nullCell; ptr = ptr.next) 
      ptr.data.UpdateHooks(bf);
  } // end UpdateHooks


  //*******************************
  //
  //  UpdateLocLabels
  //
  // recompute the coordinates of labels
  // for all points
  //??? not needed - work on
  //******************************
  
  public void UpdateLocLabels(FramePoint bf, 
			      Point or, boolean wOrient, Rational unitL) 
  {
    /*
    for (LList ptr = ptList; ptr != Constants.nullCell; ptr = ptr.next) 
      ptr.data.UpdateLocLabels(bf,or, wOrient, unitL);

      */
  } // end UpdateLocLabels


  
  //*******************************
  //
  //  ChangeOrigin
  //
  //******************************
  
  public void changeOrigin(Point newOrigin) 
  {
    or = newOrigin;
    AbsToRel();
    // UpdateLocLabels(bf,or, wOrient, unitL); ??? work on - maybe for lines
    UpdateHooks(bf); 

    notifyObservers();
  } // end changeOrigin
  
  //*******************************
  //
  //  ChangeUnitLength
  //
  //******************************
  
  public void changeUnitL(Rational ul) 
{
    unitL = ul;
    AbsToRel();
    //UpdateLocLabels(bf,or, wOrient, unitL); ??? work on - maybe for lines    

    UpdateHooks(bf); 

    notifyObservers();
  } // end changeUnitL


  //*******************************
  //
  //  ChangeUnitLengthUp
  //  doubles the unit length
  //
  //******************************

  public void changeUnitLup() 
  {
    if (unitL.d % 2 == 0)
      unitL.d = unitL.d / 2;
    else unitL.n = unitL.n * 2;
    
    AbsToRel();
  //UpdateLocLabels(bf,or, wOrient, unitL); ?? work on - maybe for lines    

    UpdateHooks(bf); 


    notifyObservers();
  } // end changeUnitLup
  

  //*******************************
  //
  //  ChangeUnitLengthDown
  //  halves the unit length
  //
  //******************************

  public void changeUnitLdown() 
  {
    if (unitL.n % 2 == 0) 
      unitL.n = unitL.n / 2;
    else unitL.d = unitL.d * 2;
    AbsToRel();
    // UpdateLocLabels(bf,or, wOrient, unitL); ?? work on - maybe for lines

    UpdateHooks(bf); 

    notifyObservers();
  } // end changeUnitLdown


  //******************************************
  //
  //  ChangeOrient
  //  changes the orientation of the y-axis
  //
  //******************************************

  public void changeOrient(boolean newOrient) 
  {
    wOrient = newOrient;
    AbsToRel();
    // UpdateLocLabels(bf,or, wOrient, unitL); ??? work on - maybe for lines

    UpdateHooks(bf); 

    notifyObservers();
  } // end changeOrient
  
  
  //************************************************
  //
  //   Resizing methods
  //
  //************************************************

  //************************************************
  //
  //  ChangeOrAfterIncrease (if wCenter is false)
  //
  //***********************************************

  public void ChangeOrAfterIncrease() 
  {
    //we have to call this function before setting the size of the PointCanvas
    //in FramePointComponentListener
    
    or.x = (int) ((or.x*bf.getSize().width)/bf.width);
    or.y = (int) ((or.y*bf.getSize().height)/bf.height);
    
  }//end of method
  

  //*******************************
  //
  //  ChangeArrayAfterIncrease
  //
  //******************************
  
  public void ChangeArrayAfterIncrease() {
    
    LList ptr;
    for(ptr = ptList; ptr != Constants.nullCell; ptr = ptr.next) {
      ptr.data.x = (int)((ptr.data.x*bf.getSize().width)/bf.width);
      ptr.data.y = (int)((ptr.data.y*bf.getSize().height)/bf.height);
    }
    
    //bf.crtPt.x = (int)((bf.crtPt.x*bf.getSize().width)/bf.width);
    //bf.crtPt.y = (int)((bf.crtPt.y*bf.getSize().height)/bf.height);
    
    notifyObservers();
    
  }//end of method
  
  
  
  
  //*******************************
  //
  //  Draw
  //
  //******************************

  public void Draw(Graphics g) 
  {    
    for(LList ptr = ptList; ptr != Constants.nullCell; ptr = ptr.next)
      ptr.data.Draw(g, bf);
  }//end of method Draw
  

  
  //*******************************
  //
  //  Print
  //
  //******************************
  
  public void Print() 
  {
    for (LList ptr = ptList; ptr != Constants.nullCell; ptr = ptr.next)
      System.out.println("( "+ptList.data.x + "," + ptList.data.y + ")");
  }//end Print 
  

  //*******************************
  //
  //  registerAsObserver
  //
  //******************************
  
  public void registerAsObserver(PointSetObserver observer) 
  {
    observers.addElement(observer);
    observer.PointSetHasChanged(this);
  }
  
  //*******************************
  //
  //  NotifyObservers
  //
  //******************************
  
  public void notifyObservers() 
  {
    Enumeration enum = observers.elements();
    while(enum.hasMoreElements()) {
      PointSetObserver observer = (PointSetObserver)enum.nextElement();
      observer.PointSetHasChanged(this);
    }
  }
  
  
//*******************************
//
// DrawLines
//
//******************************

public void DrawLines (Graphics g, int duality) {
  
  LList ptr;
  
  int width = bf.lf.lc.getSize().width;
  int height = bf.lf.lc.getSize().height;
  
  for(ptr = ptList; ptr != Constants.nullCell; ptr = ptr.next)
    ptr.data.DrawLine(g, width, height, or, wOrient, unitL, duality);



}//end of DrawLines



  //***********************
  //
  // RectSelect
  //
  // selects points in a rectangle
  //
  //***********************

public void RectSelect() {
    
    LList ptr = ptList; 
    
    while (ptr != Constants.nullCell) {
	
	if ((ptr.data.x > bf.p1.x) && (ptr.data.x < bf.p2.x)) {
	    
	    if ((ptr.data.y > bf.p1.y) && (ptr.data.y < bf.p2.y)) 
		ptr.data.selected = StateSelect.yes;
	    else if ((ptr.data.y < bf.p1.y) && (ptr.data.y > bf.p2.y))
		ptr.data.selected = StateSelect.yes;
	    else ptr.data.selected = StateSelect.not;
	}
	
	else if ((ptr.data.x > bf.p2.x) && (ptr.data.x < bf.p1.x)) {
	    
	    if ((ptr.data.y > bf.p2.y) && (ptr.data.y < bf.p1.y)) 
		ptr.data.selected = StateSelect.yes;
	    else if ((ptr.data.y < bf.p2.y) && (ptr.data.y > bf.p1.y))
		ptr.data.selected = StateSelect.yes;
	    else ptr.data.selected = StateSelect.not;
	    
	}
	
	else ptr.data.selected = StateSelect.not;

	ptr = ptr.next;    
	
    }// end while
    
    notifyObservers();     
    
}// end RectSelect



}//end class PointSet