package actionObjects;
public class userInput { 
      public userInput()
    public void setInput(String s)
}
 
public class Driver extends Application{ 
      public void start(Stage stage)
}
 
package model.commands;
public class AndNode extends LogicCommand{ 
  	public AndNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class ArcTangentNode extends MathCommand{ 
  	public ArcTangentNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class BackwardNode extends TurtleCommand{ 
  	public BackwardNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public void printName()
	public double execute(Controller control) 
}
 
package model.commands;
public class BlankNode extends TurtleCommand{ 
  	public BlankNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class ClearScreenNode extends TurtleCommand{ 
  	public ClearScreenNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public abstract class Command { 
  	public Command(String command)
	public String getName()
	public void addChild(Command newChild)
	//public void addChild()
	public List<Command> getChildren()
	//public List<Integer> getChildren()
	public int getNumChildren()
	public void updateLocation(ListOfCommands commandList) 
	public double executeChild(int i, Controller control)
	public abstract double execute(Controller control);
}
 
package model.commands;
public class CommandNode extends ControlCommand{ 
  	public CommandNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control)
}
 
package model.commands;
public class ConstantNode extends TurtleCommand{ 
  	public ConstantNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public void printName()
	public double execute(Controller control) 
}
 
package model.commands;
public abstract class ControlCommand extends Command{ 
  	public ControlCommand(String command) 
	public void moveThroughList(ListOfCommands commandList, CommandFactory nodeMaker, Command parent,
	public void checkForListStart(ListOfCommands commandList, Controller control) throws Exception
	public void isVariable(String command, Controller control) throws VariableDoesNotExistException
	public boolean isEndList(String command)
	public abstract double execute(Controller control);
}
 
package model.commands;
public class CosineNode extends MathCommand{ 
  	public CosineNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class DifferenceNode extends MathCommand{ 
  	public DifferenceNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control)  
}
 
package model.commands;
public class DoTimesNode extends ControlCommand{ 
  	public DoTimesNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public void printName()
	public double execute(Controller control) 
}
 
package model.commands;
public class EndParsingNode extends Command{ 
  	public EndParsingNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class EqualNode extends LogicCommand{ 
  	public EqualNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class ForNode extends ControlCommand{ 
  	public ForNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public void printName()
	public double execute(Controller control) 
}
 
package model.commands;
public class ForwardNode extends TurtleCommand{ 
  	public ForwardNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public void printName()
	public double execute(Controller control) 
}
 
package model.commands;
public class GreaterThanNode extends LogicCommand{ 
  	public GreaterThanNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class HeadingNode extends TurtleCommand{ 
  	public HeadingNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class HideTurtleNode extends TurtleCommand{ 
  	public HideTurtleNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class HomeNode extends TurtleCommand{ 
  	public HomeNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class IfElseNode extends ControlCommand{ 
  	public IfElseNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public void printName()
	public double execute(Controller control) 
}
 
package model.commands;
public class IfNode extends ControlCommand{ 
  	public IfNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public void printName()
	public double execute(Controller control) 
}
 
package model.commands;
public class IsPenDownNode extends TurtleCommand{ 
  	public IsPenDownNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class IsShowingNode extends TurtleCommand{ 
  	public IsShowingNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class LeftNode extends TurtleCommand{ 
  	public LeftNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class LessThanNode extends LogicCommand{ 
  	public LessThanNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public abstract class LogicCommand extends Command { 
  	public LogicCommand(String command) 
	public abstract double execute(Controller control);
}
 
package model.commands;
public class MakeUserInstructionNode extends ControlCommand{ 
  	public MakeUserInstructionNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public void checkVariableList(int row, int col, ListOfCommands commandList, Controller control) throws Exception
	public void printName()
	public double execute(Controller control) 
}
 
package model.commands;
public class MakeVariableNode extends ControlCommand{ 
  	public MakeVariableNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public void printName()
	public double execute(Controller control) 
}
 
package model.commands;
public abstract class MathCommand extends Command { 
  	public MathCommand(String command) 
	public abstract double execute(Controller control);
}
 
package model.commands;
public class MinusNode extends MathCommand{ 
  	public MinusNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class NaturalLogNode extends MathCommand{ 
  	public NaturalLogNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class NotEqualNode extends LogicCommand{ 
  	public NotEqualNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class NotNode extends LogicCommand{ 
  	public NotNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class OrNode extends LogicCommand{ 
  	public OrNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class PenDownNode extends TurtleCommand{ 
  	public PenDownNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class PenUpNode extends TurtleCommand{ 
  	public PenUpNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class PiNode extends MathCommand{ 
  	public PiNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class PowerNode extends MathCommand{ 
  	public PowerNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class ProductNode extends MathCommand{ 
  	public ProductNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class QuotientNode extends MathCommand{ 
  	public QuotientNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class RandomNode extends MathCommand{ 
  	public RandomNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class RemainderNode extends MathCommand{ 
  	public double execute(Controller control) 
}
 
package model.commands;
public class RepeatNode extends ControlCommand{ 
  	public RepeatNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public void printVal()
	public double execute(Controller control) 
}
 
package model.commands;
public class RightNode extends TurtleCommand{ 
  	public RightNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class SetHeadingNode extends TurtleCommand{ 
  	public SetHeadingNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class SetPositionNode extends TurtleCommand{ 
  	public SetPositionNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class SetTowardsNode extends TurtleCommand{ 
  	public SetTowardsNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class ShowTurtleNode extends TurtleCommand{ 
  	public ShowTurtleNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control)
}
 
package model.commands;
public class SineNode extends MathCommand{ 
  	public SineNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class SumNode extends MathCommand{ 
  	public SumNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class TangentNode extends MathCommand{ 
  	public TangentNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public abstract class TurtleCommand extends Command { 
  	public TurtleCommand(String command)
	public abstract double execute(Controller control);
}
 
package model.commands;
public class VariableNode extends TurtleCommand{ 
  	public VariableNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class XCoordinateNode extends TurtleCommand{ 
  	public XCoordinateNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model.commands;
public class YCoordinateNode extends TurtleCommand{ 
  	public YCoordinateNode(ListOfCommands commandList, CommandFactory nodeMaker, Controller control) throws Exception 
	public double execute(Controller control) 
}
 
package model;
public class Controller { 
  	public static Controller getInstance()
	public Controller()
	public boolean isExecuting(String command)
	public void addNumParam(String command, int count)
	public int getNumParam(String command)
	public void changeExecutingValue(String command, boolean value)
	public void addVariable(String name, double value)
	public String getUserCommand()
	public double getVariableValue(String variableName)
	public void addCommand(String key, Command value)
	public Map<String, Command> getCommands()
	public void checkForCommand(String command, Controller control) throws CommandDoesNotExistException
	public Command findCommand(String command)
	public void setUp()
	public Command getTree() throws Exception
	public void executeTree(Command head) throws NullPointerException
	public Map<String,Double> getVariables()
	public Turtle getTurtle()
	//public void setTurtleModel(Turtle turtle)
	public TurtleView updateTurtleView()
	public void addHistory(String command)
	public List<String> getHistory()
	public void enterAction(String command) throws Exception 
	public void UpdateView() 
}
 
package model;
public class ExceptionManager { 
  	public ExceptionManager()
	public void resetErrors()
	public boolean hasErrors()
	public void printError()
	public void addError(String error)
}
 
package model.exceptions;
public class CommandDoesNotExistException extends Exception{ 
  	public CommandDoesNotExistException(String error)
	public String getError()
}
 
package model.exceptions;
public class MissingListEndException extends Exception{ 
  	public MissingListEndException(String error)
}
 
package model.exceptions;
public class MissingListStartException extends Exception{ 
  	public MissingListStartException(String temp)
	public String getError()
}
 
package model.exceptions;
public class VariableDoesNotExistException extends Exception{ 
  	public VariableDoesNotExistException(String error)
    public String getError()
}
 
package model;
public class ModelMain { 
  }
 
package model.parser;
public class CommandFactory { 
  	public Object getCommand(ListOfCommands commandList, Controller control) throws Exception
}
 
package model.parser;
public class ExpressionTreeBuilder { 
  	public Command makeTree(Controller control) throws Exception
}
 
package model.parser;
public class InputReader { 
  	public InputReader(String userInput)
    public List<List<String>> getInputtedCommands()
}
 
package model.parser;
public class ListOfCommands { 
  	public ListOfCommands(List<List<String>> commandList, int row, int col)
	public boolean isOutOfBounds()
	public List<String> getRowList()
	public String getCommand() throws Exception
	public int getNumRows()
	public int getRowLength()
	public int getRow()
	public int getCol()
	public void endParse()
	public void setRow(int row)
	public void setCol(int col)
}
 
package model.parser;
public class ProgramParser { 
      public ProgramParser () 
    public void addPatterns (String syntax) 
    public String getSymbol (String text) 
}
 
package model.regularExpression;
public class Main { 
  }
 
package model;
		myController.UpdateView(); //Give to controller then package up into Turtle View which is just a list of sttributes, the send to View.
public class Turtle { 
  	public Turtle(Controller controller)
	public void setImage(String pngfile) 
	public int getErrorState()
	public void setErrorState(int errorNum)
	public double move(double vector)
	public double towards(double x, double y)
	public double orientQuadrant(double quadrant,double angle, double currentAngle)
	public void setPosition(double x, double y)
	public double getNewPositionX()
	public double getNewPositionY()
	public double getOldPositionX()
	public double getOldPositionY()
	public double changeOrientation(double angle)
	public void setOrientation(double angle)
	public double getOrientation()
	public void clearScreen()
	public void showTurtle()
	public void hideTurtle()
	public void penUp()
	public void penDown()
	public double getAngle()
	public ImageView getImage() 
	public boolean isRevealBoolean() 
	public boolean isPenBoolean() 
	public boolean isClearScreen() 
	public void setClearScreenOff()
}
 
package model;
public class TurtleFactory { 
  	public Turtle createTurtle(Controller control) 
}
 
package model;
public class TurtleView { 
  	public TurtleView(Turtle turtle)
	public int getErrorState()
	public double getOldXpos() 
	public double getOldYpos() 
	public double getNewXpos() 
	public double getNewYpos() 
	public boolean isRevealBoolean() 
	public boolean isPenBoolean() 
	public boolean isClearScreen() 
	public double getAngleNow() 
}
 
package screens;
public abstract class ActionScene { 
      public ActionScene(Scene scene, ResourceBundle resource, int height, int width)
    public Scene getScene()
    public Group getRoot()
    public void setRoot(Group r)
}
 
package screens;
public class MainMenu { 
      public Scene init(Stage stage, int width, int height, ResourceBundle resources)
}
 
package screens;
public class SLogoScene extends ActionScene{ 
      public SLogoScene(Scene scene, ResourceBundle resource) throws Exception
    public void setScene() throws Exception
    public Button getEnter()
    public Button getClear()
    public void changeBackgroundColor(Color color)
    public ColorPicker getBackgroundPicker()
    public Button getImagePicker()
    public ListView<String> getCommandHistory()
    public ListView<String> getCurrCommands()
    public ListView<String> getCurrVariables()
    public void changeTurtleImage(String pic)
    public ComboBox<String> getLanguageChooser()
    public ColorPicker getPenColorPicker()
    public void setPenColor(Color c)
    public String getCommand()
    public void setText(String str)
    public void drawTurtle(double x, double y)
    public void makeTurtleInvisible()
    public void makeTurtleVisible()
    public void clear()
    public void rotateTurtle(double angle)
    public void drawLine(double xPrev, double yPrev, double x, double y)
}
 
package View;
public class CanvasGenerator { 
      public GraphicsContext getContext()
    public CanvasGenerator()
    public Canvas createCanvas()
    public void changeBackgroundColor(Color color)
    public void clear()
    public void setBounds(double maxY,double minY,double maxX,double minX)
    public double getBoundMinX()
    public double getBoundMinY()
    public double getBoundMaxX()
    public double getBoundMaxY()
}
 
package View;
public class DisplayGenerator { 
      public void setGridPane(int columns)
    public GridPane setScene(List<Control> toolbar,List<ListViewNamer> listViews,TextArea commandLine,
}
 
package View;
public class ListViewNamer { 
      public ListViewNamer(String n)
    public String getName()
    public ListView<String> getListView()
}
 
package ViewLogic;
public class DisplayUpdater implements ViewToModelInterface{ 
      public DisplayUpdater(SLogoScene s, Controller control)
    public void setUp() throws Exception
    public void setText(String str)
    public void setCoordinate(boolean penDown, double xPrev, double yPrev, double x, double y)
    public String getLanguage()
    public void updateHistory(String object)
    public void updateCurrCommands(String object)
    public void updateCurrVariables(String object)
    public void setVisible(boolean visible)
    public void setOrientation(double angle)
    public void resetToHome()
    public void clear()
            public void handle(MouseEvent m) 
            public void handle(MouseEvent m)
            public void handle(MouseEvent event) 
	public void updateScreen(TurtleView turtleView) 
	public void handleError(String error)
}
 
package ViewLogic;
 public interface ViewToModelInterface {
      public void setVisible (boolean visible);
    public void setCoordinate (boolean penDown, double xPrev, double yPrev, double x, double y);
    public void setOrientation (double angle);
    public void updateHistory (String o);
    public void updateCurrCommands (String object);
	public void resetToHome();
	public void clear();
    public String getLanguage();
    public void updateCurrVariables (String object);
}