package //PACKAGE NAME;

import java.awt.*;
import java.applet.Applet;
import graphingApplet.*;
import functionParser.*;
import java.util.*;


//RENAME THE CLASS -- UNLESS YOU WANT THE APPLET TO BE CALLED TEMPLATE
public class Template extends GraphingApplet{


/////////// SUBCLASS INSTANCE VARIABLES HERE  ////


//This is the place to declare all of the variables your applet will use.
//The might be lots or only a few, depending on what it does. But it is assumed
//that at least you will want one or more function entering panels and 
//corresponding evaluators. So we put that in this section. That's also so 
//we can include in this templae the lines needed to get these "hooked up" to the
//rest of the applet.


FunctionEnteringPanel fPanel;
Evaluator  eval;



/////////////////////////////////////////////////
//
//  NOW FOR init()
//
/////////////////////////////////////////////////
	
public void init(){//THE FIRST THING TO DO IS TO CALL init() OF THE SUPERCLASS
	super.init();
	
	
	
	///////////// ADD FUNCTION PANELS //////////
	
	//NOW WE BEGIN ADDING THE BUILDING BLOCKS WE NEED. FIRST THE FunctionEnteringPanel(s).
	//IN THIS TEMPLATE WE JUST DECLARED ONE, fPanel, SO CONSTRUCT IT.
	
	fPanel = new FunctionEnteringPanel(mc,"(2+4*x)/(2+x^2)","x","f");
	
	//NEXT, PLACE IT IN AN ARRAY, fep. THIS IS A PUBLIC VARIABLE OF THE SUPERCLASS
	//SO WE DON'T NEED TO DECLARE IT. THE ARRAY MAY SEEM SILLY WITH JUST ONE FunctionEnteringPanel,
	//BUT THIS IS BECAUSE WHEN IT COMES TIME TO POSITION IT IN THE APPLET WINDOW, WE
	//WILL DO THIS BY PASSING fep TO A BottomPanel OBJECT -- PART OF THE GraphingApplet
	//PACKAGE -- WHICH WILL TAKE CARE OF THE PLACEMENT OF HOWEVER MANY FunctionEnteringPanels
	//THERE ARE IN fep. THIS BOTH HIDES AND ENCAPSULATES USE OF THE LAYOUT MANAGERS, SO
	//YOU DON'T NEED TO DEAL WITH THEM USING THIS TEMPLATE, AND SO LATER VERSIONS OF 
	//THE GraphingApplet PACKAGE CAN TAKE ADVANTAGE OF COMING  IMPROVEMENTS TO THE
	//LAYOUT CAPABILITES OF THE AWT.
	 
	fep = new FunctionEnteringPanel[1];  // fep IS A SUPERCLASS VARIABLE, SO NO DECLARATION
	fep[0] = fPanel;
	
	
    //NOW THAT WE'VE GOT THAT DONE, LETS DEAL WITH THE CARDS.
	
	////// FIRST, SET CARD LABELS AND NAMES, INCLUDING NUMBER //////////
	//
	// IN THIS EXAMPLE, LET'S ASSUME THAT WE HAVE JUST THREE CARDS: A CursorReport,
	// A GraphParameters, AND A ReportingSlate SUBCLASS.
	// WE CHOOSE LABELS FOR THEM -- THESE WILL APPEAR BESIDE THE CORESPONDING RADIO
	// BUTTONS IN THE CardSelector -- AND THE NAMES UNDER WHICH THEY WILL BE REGISTERED
	// WITH THE Message Center.
	
	labels =  new String[3];     // labels IS A SUPERCLASS VARIABLE, SO NO DECLARATION
	labels[0] = "cursor position";
	labels[1] = "graph range controls";
	labels[2] = "slate";
	
	
	cardNames =  new String[3];  // cardNames IS A SUPERCLASS VARIABLE, SO NO DECLARATION.
	cardNames[0] = "cursor";
	cardNames[1] = "graph";
	cardNames[2] = "feedback";
	
	////////////////////////////////////////////
	//
	// NOW WE ARE READY TO CONSTRUCT THE CardSelector -- A PUBLIC VARIABLE OF THE SUPERCLASS.
	// IT JUST NEEDS TO KNOW THE NAMES AND LABELS. THE CARDS THEMSELVES GO IN A Cardbox.
	
	selector = new CardSelector(cardbox, labels, cardNames, mc);
	
	////////////////////////////////////////////
	//
	// NOW ITS TIME TO CONSTRUCT THE CARDS. FIRST THE TWO "OUT OF THE BOX" CARDS:
	//
	
	cr = new CursorReport(mc);  // cr IS A SUPERCLASS VARIABLE, SO NO DECLARATION. 
	
	gp = new GraphParameters(mc,this);  // gp IS A SUPERCLASS VARIABLE, SO NO DECLARATION.
		
	//////////////////////////////////////////
	//
	// AND NEXT THE SUBCLASS OF ReportingSlate. HERE WE'LL MAKE A TemplateSlate. OF COURSE
	// YOU NEED TO WRITE THE CODE FOR SUCH A SUBCLASS.
	//
	rs = new TemplateSlate(mc,"slate");  // rs IS A SUPERCLASS VARIABLE, SO NO DECLARATION.
	
	
	///////////////////////////////////////////
	//
	// NOW THAT WE'VE GOT OUR CARDS, WE PUT THEM IN AN ARRAY -- AGAIN, ALREADY DECLARED IN THE
	// SUPERCLASS -- THAT WILL BE PASSED TO A Top Panel OBJECT. THIS WILL TAKE CARE OF ALL THE
	// LAYOUT ISSUES AUTOMATICALLY -- AS WITH THE BottomPanel, ITS PURPOSE IS TO HIDE AND
	// ENCAPSULATE THESE.
	
	
	cards = new Panel[3];  // cards IS A SUPERCLASS VARIABLE, SO NO DECLARATION.
	
	cards[0] = cr;
	cards[1] = gp;
	cards[2] = rs;
	
	
	/////////////////////////////////////////////
	//
	////// NOW FOR THE GRAPH AND ITS ASSOCIATED WIDGETS...
	//
	
	gc = new GraphCanvas(mc,"graphCanvas");  // gc IS A SUPERCLASS VARIABLE, SO NO DECLARATION
	
	//////NEXT, CONSTRUCT A CursorBadge OF THE MATCHING WIDTH
	//
	
	cbdg = new CursorBadge(mc,(gc.getPreferredSize()).width); // cbdg IS A SUPERCLASS VARIABLE, SO NO DECLARATION
	
	//////NEXT, CONSTRUCT A GraphLocationBadge OF THE MATCHING WIDTH
	//
	
	glbdg = new GraphLocationBadge(mc,(gc.getPreferredSize()).width); // glbdg IS A SUPERCLASS VARIABLE, SO NO DECLARATION
	
	///////////////////////////////////////////////
	//
	//FINALLY, THE COPYRIGHT PANEL:
	//
	
	copyPanel = 
	new CopyrightPanel("copyright string or other authorship notice",font);
	
	// copyPanel IS A SUPERCLASS VARIABLE, SO NO DECLARATION.
	// OF COURSE YOU SHOUD USE AN APPROPRIATE STRING IN THE CONSTRUCTOR.
	
	////////////////////////////////////////////////
	
	
	//AT THIS POINT, STEP(1) IS ALMOST DONE -- THE FOUR KEY ARRAYS 
	//ARE READY TO BE USE TO CONSTRUCT top AND bottom, THE OBJECTS THAT MANAGE LAYOUTS
	//FOR ALL THE WIDGETS WE JUST MADE.
	
	///////////////////////////////////////////////
	
	top = new TopPanel(this);  // top IS A SUPERCLASS VARIABLE, SO NO DECLARATION.
	bottom = new BottomPanel(mc,fep);  //  IS A SUPERCLASS VARIABLE, SO NO DECLARATION.
	
	///////////////////// STEP (1) IS DONE //////////////
	
	///////////// NOW FOR STEP (2):
	//
	
	add(top);
	add(bottom);
	
	////////////////////////
	//
	// AT THIS POINT ALL OF THE OBJECTS THAT ARE GOING TO COMMUNICATE WITH THE 
	// MessageCenter HAVE BEEN CONSTRUCTED. DURING CONSTRUCTION, THESE ADDED NAMED DATA TO
	// EXPANDABLE LISTS THERE, WHICH IS CONVENIENT WHEN WE DON'T KNOW HOW LONG THE LISTS
	// WILL BE. NOW WE DO, SO IT IS TIME TO MOVE THE NAMED DATA TO ARRAYS FROM WHICH IT
	// CAN BE RAPIDLY ACCESSED.THE READING AND WRITING METHODS OF THE MessageCenter
	// EXPECT TO FIND THE LISTS IN THESE ARRAYS, SO THEY SHOULD BE PUT THERE AS 
	// SOON AS THEY CAN BE..
	
	mc.arrayConversion();  // NOTHING THAT CALLS mc (EXCEPT TO SUBSCRIBE) ABOVE HERE...
	gc.updateParameters();// NOTHINNG THAT USES GRAPH PARAMETERS ABOVE HERE...
	
	////////CHOOSE A CARD TO SHOW...
	//
	selector.showNamedCard("cursor"); 
	
	////////////////////////////////////////////////////////
	//
	//NOW COMES INITIALIZATION OF SUBCLASS INSTANCE VARIABLES 
	//
	// IN THIS CLASS, THERE IS JUST ONE TO DEAL WITH: eval. WE CALL UP THE MESSAGE CENTER
	// AND ASSIGN TO eval THE Evaluator OF fPanel. SINCE THIS WILL LIKELY BE NEEDED A LOT,
	// THIS ONCE AND FOR ALL ASSIGMENT SAVES US A LOT OF CALLS TO THE MessageCenter.

	eval = mc.getEvaluator("f");
	
	////////////////////////////////////////////////////
	//
	//AND THEN FINALY, THE PRELIMINARY COMPUTATIONS.
	
	handleAllData();//THIS HAS TO BE DEFINED BELOW; ABSTRACT IN Super
	
	
	
	}////////////////   END OF INIT   ///////////////////
	
	
	
	///////////////////////
	//
	// NOW THE METHODS THAT MUST BE IMPLEMENTED
	//
	
	public void runNamedMethod(String name, int i,int j){
		
		if(name.equals("click")){
		
		// DO SOMETHING TO DEAL WITH MOSE CLICKS IN THE GRAPH. THIS METHOD WILL
		// BE PASSED "click" ON MouseUp ENENTS IN THE GRAPH CANVAS. IF YOU LEAVE IT,
		//NO PROBLEM -- NOTHING WILL HAPPEN THEN.
		
		}else{
		
		// DEAL WITH OTHER POSSIBLE INPUT STRINGS THAT WILL BE PASSED TO THIS METHOD
		// WHEN BUTTONS YOU MAKE ON CARDS -- E.G. THE TemplateSlate -- ARE  PUSHED.
		// OR WHATEVER SORT OF NAMED MATHODS YOU NEED.
		
		}
		
		}//END OF RUN NAMED METHOD 
		
	
	

	
		
	public void handleAllData(){
	
		// COMPUTATIONS AND SETUP THAT ARE DONE PRELIMINARY TO ANY USER INPUT
		// AND TO BE DONE AGAIN WHEN THE FUNCTIONS ARE CHANGED WITH THE FunctionEnteringPanel.
	
		  
		}// END OF HANDLE ALL DATA.
		

		
	public void doAllPainting(){
		
	 	//THIS IS CALLED BY THE GraphCanvas's Paint(Graphics g) METHOD AFTER IT HAS PAINTED IN
	 	//THE BACKGROUND OF THE GRAPH.
		
		
		}//END OF DO ALL PAINTING
		
		
	//////////////// UTILITY METHODS
	//
	// THE FIRST OF THESE RESTORES PARAMETERS TO THEIR DEFAULT VALUES BEFORE THERE WAS ANY
	// USER INPUT. IT WILL BE CALLED AUTOMATICALLY WHENEVER A NEW FUNCTION IS ENTERED.
	// WE DIDN'T DECLARE ANY PARAMETER VARIABLES IN THIS TEMPLATE, BUT TO MAKE THINGS CLEAR,
	// SUPPOSE WE HAD TWO BOOLEANS -- clicked AND clickedTwice TO KEEP TRACK OF
	// USER INPUT (See the example applet on secant lines) BECAUSE WHAT
	// GETS PAINTED MIGHT DEPEND ON HOW MANY CLICKS THERE WERE YET. 
	// WE'D RESET THESE TO FALSE WHEN THE FUNCTION CHANGED. IN THE EXAMPLE WE MENTIONED,
	// THERE IS ALSO AN INTEGER REGISTERED WITH THE MessageCenter FOR KEEPING TRACK OF
	// CLICKS SO THAT OTHER COMPONENTS CAN ADJUST THEIR BEHAVIOR ACCORDINGLY (The ReportingSlate
	// does in the example). SO THAT SHOULD BE SET TO THE DEFAULT VALUE TOO. 
	
	
		
	public void cleanInput(){
		clicked = false;
		clickedTwice = false;
		mc.writeIntData("clicks",0);
		}
	
	public void refreshGraphs(){
		gc.repaint();  
		// THIS IS PRETTY STANDARD, BUT YOU MIGHT WANT TO ADD CODE TO THIS.
		// THIS GETS CALLED (THROUGH THE MessageCenter) BY SEVERAL OF THE WIDGETS AFTER
		// THEY'VE DONE SOMETHING THAT REQUIRES REPAINTING OGF THE GRAPH. YOU'D CERTAINLY
		// NEED TO ADD MORE CODE IF YOU HAD TWO OR MORE GRAPHS, BUT OTHERWISE, THIS SHOULD DO IT.
		}

}//END OF CLASS