package command;
public abstract class AbstractCommand { 
      public abstract double execute();
    public List<AbstractCommand> getExpression () 
    public String toString() 
}
 
package command.assignment;
public class Set extends ParameterCommand{ 
      public double execute () 
}
 
package command.assignment;
public class To extends ParameterCommand{ 
      public static final int MY_NUMBER_OF_COMMAND_PARAMETERS = 3; //maybe switch to getNumberOfParameter()
    public double execute () 
}
 
package command.booleans;
public class And extends AbstractCommand { 
      public And (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute() 
}
 
package command.booleans;
public class Equal extends AbstractCommand { 
      public Equal (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute() 
}
 
package command.booleans;
public class Greater extends AbstractCommand { 
      public Greater (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute() 
}
 
package command.booleans;
public class Less extends AbstractCommand { 
      public Less (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute() 
}
 
package command.booleans;
public class Not extends AbstractCommand { 
      public Not (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute() 
}
 
package command.booleans;
public class NotEqual extends AbstractCommand { 
      public NotEqual (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute() 
}
 
package command.booleans;
public class Or extends AbstractCommand { 
      public Or (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute() 
}
 
package command;
public abstract class CalculationCommand extends AbstractCommand { 
  }
 
package command;
public abstract class CommandFactory {     public static final Map<String, Variable> myVariableMap = new HashMap<String, Variable>(); /// TODO: //temporary, will probably remove from abstract class      * public static class CursorNode implements Node{      * public static class ConstantNode implements Node{      * public interface Node {
      public static final Map<String, Variable> myVariableMap = new HashMap<String, Variable>(); /// TODO: //temporary, will probably remove from abstract class
     * public AbstractCommand createCommand() 
     * public Node getNext () 
     * public void setNext (Node nextNode) 
     * public String getCommandType () 
     * public AbstractCommand createCommand() 
     * public Node getNext () 
     * public void setNext (Node nextNode) 
     * public String getCommandType () 
    public AbstractCommand createCommand (Node node) 
}
 
package command;
public class ConstantCommandFactory extends CommandFactory { 
      public ConstantCommandFactory (double value) 
}
 
package command.control;
public class If extends AbstractCommand { 
      public double execute () 
}
 
package command.control;
public class IfElse extends AbstractCommand { 
      public double execute () 
}
 
package command.cursor;
public class Back extends CursorCommand { 
      public Back (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.cursor;
public class ClearScreen extends CursorCommand { 
      public ClearScreen (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.cursor;
public class Forward extends CursorCommand { 
      public Forward (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.cursor;
public class HideTurtle extends CursorCommand { 
      public HideTurtle (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.cursor;
public class Home extends CursorCommand { 
      public Home (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.cursor;
public class Left extends CursorCommand { 
      public Left (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.cursor;
public class PenDown extends CursorCommand { 
      public PenDown (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.cursor;
public class PenUp extends CursorCommand { 
      public PenUp (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.cursor;
public class Right extends CursorCommand { 
      public Right (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.cursor;
public class SetHeading extends CursorCommand { 
      public SetHeading (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.cursor;
public class SetXY extends CursorCommand { 
      public SetXY (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.cursor;
public class ShowTurtle extends CursorCommand { 
      public ShowTurtle (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.cursor;
public class Towards extends CursorCommand { 
      public Towards (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command;
public abstract class CursorCommand extends AbstractCommand { 
      public Cursor getCursor () 
    public abstract double execute();
    public void setCursor (Cursor myCursor) 
}
 
package command;
public class CursorCommandFactory extends CommandFactory { 
      public CursorCommandFactory (Cursor cursor) 
}
 
package command.iteration;
public class DoTimes extends ParameterCommand { //TODO - maybe subclass based on iteration 
      public double execute () 
    public Constant createConstant(double value) 
}
 
package command.iteration;
public class For extends ParameterCommand { //TODO - maybe subclass based on iteration 
      public double execute () 
}
 
package command.iteration;
public class Repeat extends ParameterCommand { //TODO - maybe subclass based on iteration 
      public double execute () 
}
 
package command.math;
public class Atan extends CalculationCommand { 
      public Atan (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command.math;
public class Cos extends CalculationCommand { 
      public Cos (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command.math;
public class Difference extends CalculationCommand { 
      public Difference (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command.math;
public class Log extends CalculationCommand { 
      public Log (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command.math;
public class Minus extends CalculationCommand { 
      public Minus (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command.math;
public class Pi extends CalculationCommand { 
      public Pi (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command.math;
public class Pow extends CalculationCommand { 
      public Pow (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command.math;
public class Product extends CalculationCommand { 
      public Product (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command.math;
public class Quotient extends CalculationCommand { 
      public Quotient (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command.math;
public class Random extends CalculationCommand { 
      public Random (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command.math;
public class Remainder extends CalculationCommand { 
      public double execute () 
}
 
package command.math;
public class Sin extends CalculationCommand { 
      public Sin (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command.math;
public class Sum extends CalculationCommand { 
      public Sum (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command.math;
public class Tan extends CalculationCommand { 
      public Tan (Map<String, Variable> variableMap, List<AbstractCommand> inputs) 
    public double execute () 
}
 
package command;
public class MultiLineCommandFactory extends CommandFactory {  
      public MultiLineCommandFactory () 
}
 
package command;
public class OperationCommandFactory extends CommandFactory { //TODO - split into ParameterCommandFactory 
      public OperationCommandFactory () 
}
 
package command;
public abstract class ParameterCommand extends AbstractCommand { 
      public abstract double execute();
}
 
package command.queries;
public class Heading extends CursorCommand { 
      public Heading (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.queries;
public class PenDown extends CursorCommand { 
      public PenDown (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.queries;
public class Showing extends CursorCommand { 
      public Showing (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.queries;
public class XCor extends CursorCommand { 
      public XCor (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.queries;
public class YCor extends CursorCommand { 
      public YCor (Map<String, Variable> variableMap, List<AbstractCommand> inputs, Cursor cursor) 
    public double execute() 
}
 
package command.utility;
public class Constant extends AbstractCommand { 
      public Constant (Map<String, Variable> variableMap, List<AbstractCommand> inputs, double value) 
    public double execute () 
}
 
package command.utility;
public class MultiLine extends AbstractCommand { 
      public double execute () 
}
 
package command.utility;
public class Variable extends AbstractCommand{ 
      public Variable(Map<String, Variable> variableMap, List<AbstractCommand> inputs, String variableName) 
    public String toString() 
    public double execute ()  //execute every command in the queue
    public void setExpressione(AbstractCommand expression) 
}
 
package command;
public class VariableCommandFactory extends CommandFactory { 
      public VariableCommandFactory (String variableName) 
}
 
package controller;
public class SlogoController { 
  	public SlogoController(SlogoWindowView view)
	public void bindUserInput()
			public void onChanged(ListChangeListener.Change c) 
}
 
package cursor;
public class Coordinate { 
      public Coordinate (double x, double y) 
    public Coordinate add (Coordinate coordinate) 
    public Coordinate subtract (Coordinate coordinate) 
    public Coordinate scale (double scaleFactor) 
    public Coordinate translate (double distance, double angle) 
    public double calculateDistance(Coordinate coordinate) 
    public boolean equals (Object obj) 
    public int hashCode () 
    public double getX () 
    public double getY () 
    public String toString () 
}
 
package cursor;
public class CreatedItem implements Drawable{ 
      public List<Coordinate> getCoordinates () 
    public void setCoordinates (List<Coordinate> myCoordinates) 
    public List<Coordinate> getCreateItems () 
    public double getLayer () 
    public double getOrientation () 
    public boolean getIsVisible () 
}
 
package cursor;
public class Cursor implements Drawable{ 
      public Cursor() 
    public Coordinate getCoordinate () 
    public double getOrientation() 
    public void setOrientation(double orientation) 
    public void setCoordinate (Coordinate coordinate) 
    public void clearCreatedItems() 
    public void createItem(Coordinate nextCoordinate) 
    public void updateCoordinate(Consumer<Coordinate> func) 
    public List<Coordinate> getCreateItems () 
    public Boolean getIsPenDown () 
    public void setIsPenDown (Boolean myIsPenUp) 
    public boolean getIsVisible () 
    public void setIsVisible (Boolean myIsVisible) 
    public double getLayer () 
}
 
package cursor;
 public interface Drawable { //TODO - maybe refactor to 
  }
 
package main;
public class Main extends Application { 
  	public void start(Stage stage) 
}
 
package node;
public class BracketNode extends Node{ 
  	public BracketNode(String type)
	public String toString()
    public AbstractCommand createCommand () 
}
 
package node;
public class ConstantNode extends Node { 
  	public ConstantNode(String type, double value)
	public String toString()
        public AbstractCommand createCommand() 
}
 
package node;
public class CursorNode extends Node { 
  	public CursorNode(String type,Cursor turtle)
	public Cursor getTurtle()
	public String toString()
    public AbstractCommand createCommand() 
}
 
package node;
public abstract class Node { 
  	public Node(String type)
	public String getType()
	public void setNext(Node next)
	public Node getNext() 
	public String toString()
	public abstract AbstractCommand createCommand();
}
 
package node;
public class OperationNode extends Node { 
      public OperationNode (String type,HashMap<String,Variable>map) 
    public String toString () 
    public AbstractCommand createCommand () 
}
 
package node;
public class VariableNode extends Node { 
  	public VariableNode(String myName, String value, String name)
	public String getName()
	public String toString()
    public AbstractCommand createCommand () 
}
 
package parser;
public class ExpressionTree { 
  	public ExpressionTree()
	public void add(Node n)
	public HashMap<String,Variable> getMap()
	public AbstractCommand createCommand()
	public String toString()
}
 
package parser;
public class InputParser { 
       public InputParser (String language) 
     public void addPatterns (String syntax) 
     public ExpressionTree parse(String input,Cursor cursor)
     public String getSymbol (String text) 
}
 
package view;
 public interface Display {
  	public void redrawAll(List<Drawable> drawables);
	public void setBackgroundColor(Color color);
	public void setPenColor(Color color);
	public Node getStackPane();
	public void setTurtleImage(String path);
}
 
package view;
public class History { 
      public History () 
    public void setBinding(ListChangeListener bind)
    public void clear() 
    public String getRecentCommand()
    public ObservableList<String> getAllCommands()
    public TextArea getTextArea()
    public TextArea getHistory() 
    public void addHistory(String input) 
}
 
package view;
public abstract class HorizontalGUIObject extends HBox { 
      public HorizontalGUIObject(String language) 
    public ResourceBundle getResources() 
}
 
package view;
public class InputField extends HorizontalGUIObject { 
      public InputField(String language) 
}
 
package view;
 public interface SlogoWindowElement {
  }
 
package view;
public class SlogoWindowView implements Window { 
      public History getHistory()
    public Scene getScene () 
    public Display getTurtleDisplay()
    public String getLanguage()
    public static Double getAppWidth()
    public static Double getAppHeight()
    public void setHistoryBinding(ListChangeListener bind)
}
 
package view;
public class Toolbar extends HorizontalGUIObject { 
  	public HBox getToolbar() 
}
 
package view;
public class TurtleDisplay implements Display { 
  	public void redrawAll(List<Drawable> drawables)
	public Node getStackPane()
	public void setBackgroundColor(Color color)
	public void setPenColor(Color color)
	public void setTurtleImage(String path)
}
 
package view;
public class VariablesAndCommands { 
  	public VariablesAndCommands() 
    public TextArea getTextArea()
    public void clear() 
    public void updateTextArea()
    public void addVariable(String varName, String varValue) 
    public void addCommand(String commandName) 
    public void addResults(String result)
}
 
package view.window;
public class BackgroundColorWindow implements Window { 
  	public static final Dimension DEFAULT_SIZE = new Dimension(200, 100);
	public BackgroundColorWindow() 
	public Scene getScene() 
	public void start() 
	public void close() 
}
 
package view.window;
public class ChooseLanguageWindow implements Window { 
  	public static final Dimension DEFAULT_SIZE = new Dimension(200, 100);
	public ChooseLanguageWindow() 
	public void start() 
	public void close() 
	public String getLanguage() 
	public Scene getScene()
	public Stage getSlogoStage() 
}
 
package view.window;
public class CursorImageWindow implements Window { 
  	public CursorImageWindow(Stage stage) 
	public Scene getScene() 
	public void start() 
	public void close() 
}
 
package view.window;
public class ErrorMessageWindow implements Window { 
  	public static final Dimension DEFAULT_SIZE = new Dimension(1000, 700);
	public ErrorMessageWindow(String errorMessage) 
	public Scene getScene() 
}
 
package view.window;
public class HelpWindow implements Window { 
  	public static final Dimension DEFAULT_SIZE = new Dimension(1000, 700);
	public HelpWindow() 
	public Scene getScene() 
}
 
package view.window;
public class PenColorWindow implements Window { 
  	public static final Dimension DEFAULT_SIZE = new Dimension(200, 100);
	public PenColorWindow() 
	public Scene getScene() 
	public void start() 
	public void close() 
}
 
package view.window;
 public interface Window {
  	public Scene getScene();
}