/* SCCS  @(#)NslDisplayFrame.java	1.16---04/28/99--16:40:51 */

// Copyright: Copyright (c) 1997 University of Southern California Brain Project.
// Copyright: This software may be freely copied provided the toplevel
// Copyright: COPYRIGHT file is included with each such copy.
// Copyright: Email nsl@java.usc.edu.

//--------------------------------------
// $Log: NslDisplayFrame.java,v $
//
// Revision 1.9  1998/01/30 20:02:27  erhan
// ver 5
//
// Revision 1.8  1997/11/06 03:15:03  erhan
// nsl3.0.b
//
// Revision 1.5  1997/05/09 22:30:24  danjie
// add some comments and Log
//
//--------------------------------------

package nslj.src.display;

import java.lang.*;
import java.lang.reflect.*;
import java.awt.*;
import java.util.*;
import nslj.src.lang.*;
import nslj.src.system.*;
import java.awt.event.*;

/**
 * The NslDisplay Frame
 *
 * @version 1.0
 * @author  Danjie Pan
 */

public class NslDisplayFrame extends Frame implements ActionListener, ItemListener
{
  Color color;
  NslDisplayVariableInput variable_input_window=null;


//ERHMOD
  public NslDisplayFrame() { 
    System.err.println("Error: NslDisplayFrame: Should not call this constructor");
    NslDisplayCanvas.Frame = this;
    NslDisplayOutOfBoundsBezier.frame = this;
  }

  public NslDisplayFrame(NslModule module) {
    //String frameName;
    frameName="";
    if (module!=null) {
	    frameName=module.getName();
    }
    if (frameName.equals("")) 
	{
	    setTitle(".nsl.NslOutFrame");
	} 
    else {
	    frameName=".nsl."+frameName;
	    setTitle(frameName);
	}
		
    addWindowListener(new WindowAdapter() 
	{
	      public void windowClosing(WindowEvent e) { 
		system.remove((NslDisplayFrame) e.getWindow()); 
		dispose(); 
	     }
	}
    );  //keep for (new WindowAdapter() 

    MenuBar mbar = new MenuBar();
    Menu m, sm;

    m = createMenu("Frame", new String[] { "New Canvas", "Remove Canvas"});
    m.addSeparator();
    sm = createMenu("Print", new String[] { "Current Canvas", "All Canvases" });
    m.add(sm);
    sm.addActionListener(new PrintActionAdapter());
    m.addSeparator();
    m.add(new MenuItem("Close"));
    m.addActionListener(new DisplayActionAdapter(this));
    mbar.add(m);

    m = createMenu("Canvas", new String[] {"Save"});
    m.addActionListener(new OptionActionAdapter(this));
    typeMenu = new NslRadioMenu("Change type", new String[] {"Area", "Bar", "Dot", "Image", "Spatial", "String", "Temporal"} );
    m.add(typeMenu);
    typeMenu.addItemListener(this);
    typeMenu.setEnabled(false);
    sm = createMenu("Options", new String [] {"Current Canvas", "All Canvases"});
    m.add(sm);
    sm.addActionListener(new OptionActionAdapter(this));
    mbar.add(m);

    m = createMenu("View", new String []{"Zoom"});
    m.addActionListener(this);
    m.addSeparator();
    NslRadioMenu rm = new NslRadioMenu("Columns", new String[] { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" });
    rm.addItemListener(new ColumnAdapter());
    m.add(rm);
    mbar.add(m);
    
    m = new Menu("Help");
    mbar.add(m);
    mbar.setHelpMenu(m);
    
//98/9/9 aa took out - will make like add_graph
/*        
        Menu r = new Menu("Reports");
        Menu at = new Menu("Apply_To");
        at.add(new MenuItem("Current_Window_Selected"));
        at.add(new MenuItem("All_Visible_Windows"));
        r.add(at);
        
        Menu rt = new Menu("Report_Type");        
        rt.add(new MenuItem("Complete_History"));
        rt.add(new MenuItem("Bezier"));
        rt.add(new MenuItem("No_History"));
        r.add(rt);
        mbar.add(r);     
*/        
//     m = new Menu("Help");
//     // Test for multithread event handling
//     mbar.add(m);
        
        //finally put up the menu bar
    setMenuBar(mbar);

    pStatus = new Panel();
    pStatus.setBackground(Color.lightGray);
    pStatus.setLayout(new FlowLayout(FlowLayout.LEFT));
    pStatus.add(new Label("Status line:           "));
    // This label would be used to display the simulation time.
    pStatus.add(new Label("        "));
    add("South",pStatus);
    Dimension d = pStatus.getSize();
    
    drawPanel = new NslDisplayPanel(this);
//    act_model= module;
//    if (module != null) {
//      module.addModelPlots(this);
//        System.err.println("Calling InitWindow");
//        module.initWindow(); 
//    } else {
//       System.err.println("Error: NslDisplayFrame: Need a NslModule.");     
//    }
/*    int plotCount = drawPanel.getComponentCount();
    if (plotCount > 0) {
      int colCount = (plotCount > 2) ? 3 : plotCount;
      drawPanel.setColumns(colCount);
      ((CheckboxMenuItem) rm.getItem(colCount - 1)).setState(true);
    } else 
      drawPanel.setColumns(1);*/
    
    
    add("Center",drawPanel);
  } // end constructor

  private Menu createMenu(String name, String[] items) {
    Menu m = new Menu(name);
    for (int i = 0; i < items.length; i++) 
      m.add(new MenuItem(items[i]));

    return m;
    }

  public NslDisplayFrame getFrame(ActionEvent evt) {
    MenuContainer menu =(MenuContainer) (evt.getSource());
  
    MenuBar top = null;
    NslDisplayFrame frame = null;
    
    while (!(menu instanceof MenuBar)) {
      menu = ((MenuComponent) menu).getParent();
    }
    frame = (NslDisplayFrame) (((MenuBar) menu).getParent());
    return frame;
  }

  public void actionPerformed(ActionEvent evt) { // for double click servicing
    try {
      drawPanel.zoomCanvas();
    } catch (Exception e) {
      System.err.println(e.toString());
    }
  }

  public void itemStateChanged(ItemEvent evt) {
    CheckboxMenuItem item = (CheckboxMenuItem) evt.getItemSelectable();
    String type = item.getLabel();
    
    try {
      drawPanel.changeCanvas(type);
      ((NslRadioMenu) item.getParent()).selectItem(type);
    } catch (Exception e) {
      System.out.println("#Warning: NslDisplayFrame: " + e.toString());
    }
  }

  public void plotSelectionChanged(String type) {
    if (type.equals("")) 
      typeMenu.setEnabled(false);
    else {
      typeMenu.setEnabled(true);
      typeMenu.selectItem(type);
    }
  }

  private class PrintActionAdapter implements ActionListener {
    public void actionPerformed(ActionEvent evt) {
      NslDisplayFrame frame = getFrame(evt);
      System.out.println("Post 1");
      if (evt.getActionCommand().equals("Current Canvas")) {
      System.out.println("Post 2");
      	try {
	  NslDisplayCanvas c = drawPanel.getCurrentCanvas();
	  PrintJob pjob = getToolkit().getPrintJob(frame,c.canvas_name, null);
	  if (pjob != null) {          
	    Graphics pg = pjob.getGraphics();
	    
	    if (pg != null) {
	      c.printAll(pg);
	      pg.dispose(); // flush page
	    }
	    pjob.end();
	  }
  	} catch (NoCanvasSelectedException e) {
	  System.err.println(e.toString());
	}

    } else if (evt.getActionCommand().equals("All Canvases")) {
      System.out.println("Post 3");
	PrintJob pjob = getToolkit().getPrintJob(frame,"Simulation", null);

	if (pjob != null)    {          
	  Graphics pg = pjob.getGraphics();

	  if (pg != null) {

	    frame.printAll(pg);
	    pg.dispose(); // flush page
	  }
	  pjob.end();
	}
      } 	  
    }
  }


  private class DisplayActionAdapter implements ActionListener {
    NslDisplayFrame frame;
    DisplayActionAdapter(NslDisplayFrame f) {frame = f;}
    public void actionPerformed(ActionEvent evt) {
      if (evt.getActionCommand().equals("Close")) {
	system.remove(getFrame(evt));
	dispose();
      } else if (evt.getActionCommand().equals("New Canvas")) {
	variable_input_window = new NslDisplayVariableInput(frame);
	variable_input_window.show();
      } else  if (evt.getActionCommand().equals("Remove Canvas"))
	try {
	  drawPanel.removeCanvas();
	} catch (NoCanvasSelectedException e) {
	  System.err.println(e.toString());
	}
    }
  }

  private class ColumnAdapter implements ItemListener {
    public void itemStateChanged(ItemEvent evt) {
      try {
	CheckboxMenuItem item = (CheckboxMenuItem) evt.getItemSelectable();
	String label = item.getLabel();
	int newColumns = Integer.parseInt(label);
	if (!drawPanel.setColumns(newColumns)) {
	  item.setState(false);
	  return;
	}
	((NslRadioMenu) item.getParent()).selectItem(label);
      } catch (Exception e) { 
	System.err.println(e.toString() /*"Error: Invalid number format."*/);
      }
    }
  }  

  private class OptionActionAdapter implements ActionListener {
    NslDisplayFrame frame;
    OptionActionAdapter(NslDisplayFrame f) { frame = f;}
    public void actionPerformed(ActionEvent evt) {
      try {
	if (evt.getActionCommand().equals("Current Canvas")) {
	  drawPanel.setCanvasProperties();
	} else if (evt.getActionCommand().equals("All Canvases")) {
	  System.out.println("Post 5");
	  NslDisplayFrameProperty fp = new NslDisplayFrameProperty(frame);
	  fp.show();
	} else if (evt.getActionCommand().equals("Save")) {
	  // 	NslDisplayCanvas ndc = (NslDisplayCanvas)canvas_list.elementAt(current_canvas_index);
	  
	  NslDisplayOutFileProperty ndofp = new NslDisplayOutFileProperty(frame);
	  ndofp.show();
	}
      } catch (NoCanvasSelectedException e) {
	System.out.println("#Warning: " + e.toString());
      }
    }
  }

    
  public static void setSystem(NslSystem sys) {
    system=sys;
    interpreter = sys.getInterpreter();
    NslDisplayVariable.system = sys;
    NslDisplayVariableInput.system = sys;
  }

  public void startCycle() {
    ((Label) pStatus.getComponent(0)).setText("Simulation running at: ");
  }

  public void collect(double time) {
    // For displaying status
      ((Label) pStatus.getComponent(1)).setText(String.valueOf(rounded(time)));    
      drawPanel.collect();
  }

  public void refresh() {
    collect(system.getCurTime());
  }
 
  public NslDisplayCanvas getCurrentCanvas() {
    try {
      return drawPanel.getCurrentCanvas();
    } catch (NoCanvasSelectedException e) {
      System.out.println("#Warning: " + e.toString());
      return null;
    }
  }

  public Vector getCanvasList() {
    return drawPanel.getCanvasList();
  }

  public void addDisplayCanvas(String name, 
			       NslDisplayVariableInfo varInfo, 
			       String plotType, 
			       boolean replace){
	    
//     if(repace_canvas_flag == 1)  {  //replace current canvas
//       ((NslDisplayCanvas)canvas_list.elementAt(current_canvas_index)).add_variable(var_sel_full_name, var_sel_info);
//     } else 
    if (!replace) 
            // append to the canvas_list
      try {
	drawPanel.addCanvas(name, varInfo, plotType);
	drawPanel.repaint();
      } catch (Exception e) {
	System.out.println("Error: NslDisplayFrame: unknown plot.");
      }
      
  }
	
  public void add_variable(String varName, boolean replace, String plotType) {
    NslDisplayVariableInfo varInfo = getVarInfo(varName);
	    // 98/8/27 aa - in development
	    //pass name,dimensions, and plot type to queryPlotWizard
    queryPlotWizardA(varName, varInfo, replace, plotType);
  }//end add_variable
 
  /**
   * Get variable reference number and other properties from  Nsl System
   *@param var_sel_full_name  The variable's full name
   *@return  A vector which contains variable's reference number and diminsions
   */

  public NslDisplayVariableInfo getVarInfo(String varName) {

    NslNumeric var_sel = system.getVariable(varName);
    
    return getVarInfo(var_sel);
  }
  
  public NslDisplayVariableInfo getVarInfo(NslNumeric var_sel) {
    NslDisplayVariableInfo info = null;
    if (var_sel==null){
      System.err.println("Error: NslDisplayFrame: Variable not found " + var_sel.getName());
    } else if (var_sel instanceof NslNumeric4) {
      int d1 = ((NslNumeric4)var_sel).getSize1();
      int d2 = ((NslNumeric4)var_sel).getSize2();
      int d3 = ((NslNumeric4)var_sel).getSize3();
      int d4 = ((NslNumeric4)var_sel).getSize4();
      info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), 4);
      info.setDimension(0,d1);
      info.setDimension(1,d2);
      info.setDimension(2,d3);
      info.setDimension(3,d4);
    }
	    //System.out.println(d1.intValue()+" "+d2.intValue());
	    //System.out.println(var_sel);
    else if (var_sel instanceof NslNumeric3) {
      if (var_sel instanceof NslFloat3)
	info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), NslDisplayVariableInfo.FLOAT, 3);
      else if (var_sel instanceof NslDouble3) 
	info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), NslDisplayVariableInfo.DOUBLE, 3);
      else if (var_sel instanceof NslInt3)
	info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), NslDisplayVariableInfo.INT, 3);

      info.setDimension(0,((NslNumeric3)var_sel).getSize1());
      info.setDimension(1,((NslNumeric3)var_sel).getSize2());
      info.setDimension(2,((NslNumeric3)var_sel).getSize3());

	    //System.out.println(d1.intValue()+" "+d2.intValue());
	    //System.out.println(var_sel);
    } else if (var_sel instanceof NslNumeric2) {
      if (var_sel instanceof NslFloat2)
	info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), NslDisplayVariableInfo.FLOAT, 2);
      else if (var_sel instanceof NslDouble2) 
	info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), NslDisplayVariableInfo.DOUBLE, 2);
      else if (var_sel instanceof NslInt2)
	info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), NslDisplayVariableInfo.INT, 2);

      info.setDimension(0,((NslNumeric2)var_sel).getSize1());
      info.setDimension(1,((NslNumeric2)var_sel).getSize2());

	    //System.out.println(d1.intValue()+" "+d2.intValue());
	    //System.out.println(var_sel);


    } else if(var_sel instanceof NslNumeric1) {
      if (var_sel instanceof NslFloat1)
	info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), NslDisplayVariableInfo.FLOAT, 1);
      else if (var_sel instanceof NslDouble1) 
	info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), NslDisplayVariableInfo.DOUBLE, 1);
      else if (var_sel instanceof NslInt1)
	info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), NslDisplayVariableInfo.INT, 1);

      info.setDimension(0,((NslNumeric1)var_sel).getSize());
    } else if ( var_sel instanceof NslNumeric0) {
      if (var_sel instanceof NslFloat0)
	info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), NslDisplayVariableInfo.FLOAT, 0);
      else if (var_sel instanceof NslDouble0) 
	info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), NslDisplayVariableInfo.DOUBLE, 0);
      else if (var_sel instanceof NslInt0)
	info = new NslDisplayVariableInfo(var_sel, var_sel.getName(), NslDisplayVariableInfo.INT, 0);
    }
    return info;
  }
    
  public void queryPlotWizardA(String name, NslDisplayVariableInfo varInfo, boolean replace, String plotType) {
    //need to know what type of plot they want
        // 98/9/4 aa
        // varInfo can change
    if (varInfo==null) {
      System.err.println("Error: " + name + ": No variable information.");
    return;
    }

    int dimsize = varInfo.getCountDimensions(); 	   
	    
    if (plotType.equals("Area") ||
	 plotType.equals("Bar") ||
	 plotType.equals("Image") ||
	 plotType.equals("Spatial") ||
	 plotType.equals("Temporal")) {
      if (dimsize == 0 || dimsize == 1 || dimsize == 2)
	addDisplayCanvas(name, varInfo, plotType, replace);
      else {
	NslDisplayDimInput dm = 
	  new NslDisplayDimInput(this, name, varInfo, 
				 plotType, replace);
	dm.show();
      }
    } else if ((plotType.equals("Dot") || 
		plotType.equals("String")) && 
	       dimsize == 2) {
	        // two-dimensional data only
      addDisplayCanvas(name,varInfo,plotType,replace);
    } else {
      System.err.println("Error: bad plot type :" + plotType);
    } 
    
  } //end queryDataWizardA

   /*---------------------------------------------------------*/
   /*ERH:if you need n decimal points call this with v=10^n.  */
  private String rounded(double t,double v,int dec) {
    String s=Double.toString(((long)(0.5+t*v))/v);
    //unfortunately s may still contain round off stuff...
    int ix=s.indexOf(".");
    if (ix==-1) return s;
    if (s.length()-ix-1 < dec) dec=s.length()-ix-1;
    return s.substring(0,ix)+s.substring(ix,ix+dec+1);
  }

  private String rounded(double t) { return rounded(t,100,2);}


    // called from nslm code

  public void  addPlot(String name) {
    addPlot(name,0.0,1.0,"Area");
  }
  
  public void  addVariableInfo(String name) {
    
    try {
      NslDisplayVariableInfo vi = getVarInfo(name);
      drawPanel.addVariable(name, vi);
    } catch (Exception e) {
      System.err.println("Error: NslDisplayFrame: Variable info could not be created. " + name);
      System.err.println("Error: "+e.toString());
	    e.printStackTrace();    }   

  }
    
  public void  addPlot(String name, double minv,double maxv,String type) {

    NslDisplayVariableInfo vi = getVarInfo(name);
    try {
      drawPanel.addCanvas(name, vi, type, minv, maxv);
   } catch (Exception e) {
      System.err.println("Error: NslDisplayFrame: Plot could not be created. " + name);
      System.err.println("Error: "+e.toString());
	    e.printStackTrace();
    }   
    
  }  //end addPlotsccs
  
  public void  addPlot(NslNumeric var, double minv,double maxv,String type) {

    NslDisplayVariableInfo vi = getVarInfo(var);
    try {
      drawPanel.addCanvas(var.getName(), vi, type, minv, maxv);
   } catch (Exception e) {
      System.err.println("Error: NslDisplayFrame: Plot could not be created. " + var.getName());
      System.err.println("Error: "+e.toString());
	    e.printStackTrace();
    }   
    
  }
      
  public void  addUserPlot(NslNumeric var, double minv,double maxv,String type) {

    NslDisplayVariableInfo vi = getVarInfo(var);
    try {
      drawPanel.addUserCanvas(var.getName(), vi, type, minv, maxv);
   } catch (Exception e) {
      System.err.println("Error: NslDisplayFrame: Plot could not be created. " + var.getName());
      System.err.println("Error: "+e.toString());
	    e.printStackTrace();
    }   
    
  }    
  
  public NslDisplayCanvas  addPlot(String windowName, String name, double minv,double maxv,String type) {
    NslDisplayCanvas c = null;
    NslDisplayVariableInfo vi = getVarInfo(name);
    try {
      c = drawPanel.addCanvas(name, vi, type, minv, maxv);
      c.setWindowName(windowName);
      
   } catch (Exception e) {
      System.err.println("Error: NslDisplayFrame: Plot could not be created. " + name);
      System.err.println("Error: "+e.toString());
	    e.printStackTrace();
    } finally {  
      return c;
    }
  }  //end addPlotsccs
  
  public NslDisplayCanvas addPlot(String windowName, NslNumeric var, double minv,double maxv,String type) {
    NslDisplayCanvas c = null;
    NslDisplayVariableInfo vi = getVarInfo(var);
    try {
      c = drawPanel.addCanvas(var.getName(), vi, type, minv, maxv);
      c.setWindowName(windowName);
      return c;
   } catch (Exception e) {
      System.err.println("Error: NslDisplayFrame: Plot could not be created. " + var.getName());
      System.err.println("Error: "+e.toString());
	    e.printStackTrace();
    } finally {  
      return c;
    }  
    
  } 
  
  public NslDisplayCanvas addUserPlot(String windowName, NslNumeric var, double minv,double maxv,String type) {
    NslDisplayCanvas c = null;
    NslDisplayVariableInfo vi = getVarInfo(var);
    try {
      c = drawPanel.addUserCanvas(var.getName(), vi, type, minv, maxv);
      c.setWindowName(windowName);
      return c;
   } catch (Exception e) {
      System.err.println("Error: NslDisplayFrame: Plot could not be created. " + var.getName());
      System.err.println("Error: "+e.toString());
	    e.printStackTrace();
    } finally {  
      return c;
    }  
    
  }
  
  public void addComponent(Component c) {
  	drawPanel.add(c);      
  	int plotCount = drawPanel.getComponentCount();
        if (plotCount > 0) {
      	   int colCount = (plotCount > 2) ? 3 : plotCount;
      	   drawPanel.setColumns(colCount);
        } else {
      	   drawPanel.setColumns(1);
        }
  	drawPanel.validate();
  }
  
  public void setColumns(int columns) {
  	drawPanel.setColumns(columns);
  }
  
  public void setRows(int rows) {
  	drawPanel.setRows(rows);
  }
  
  public void setFontName(String name) {
      //System.out.println("Font: "+name);
      fontName = name;
  }
  
  public String getFontName() {
      return fontName;  
  }
  
  public void setBackgroundColor(String name) {
      //System.out.println("Bg  : "+name);
      bg = name;      
      //setBackground(NslDisplayColor.getColor(bg));
  }
  
  public String getBackgroundColor() {
      return bg;  
  }
  
  public void setForegroundColor(String name) {
      //System.out.println("Fg  : "+name);
      fg = name;
  }
  
  public String getForegroundColor() {
      return fg;  
  }
  
  public NslDisplayPanel getPanel() {
  	return drawPanel;
  }
  
  static NslSystem system;
  static NslInterpreter interpreter;
  public String frameName;
  private String fontName, fg, bg;
  private NslDisplayPanel drawPanel;
  private Panel pStatus;
  private NslModule act_model;
  NslRadioMenu typeMenu;
}