package BackEndCommands.BooleanOperations;
public class And implements Command{ 
  	public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.BooleanOperations;
public class Equal implements Command { 
  	public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.BooleanOperations;
public class Greater implements Command { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.BooleanOperations;
public class GreaterThan implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.BooleanOperations;
public class Less implements Command { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.BooleanOperations;
public class LessThan implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.BooleanOperations;
public class Not implements Command{ 
  	public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.BooleanOperations;
public class NotEqual implements Command{ 
  	public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.BooleanOperations;
public class Or implements Command{ 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands;
public class Comment implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands;
public class Constant implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands;
public abstract class ControlCommand implements Command { 
      public abstract double executeCommand(List<Double> args);
    public abstract int numArguments();
    public void setExecutables(List<ParseTreeNode> rootsToAdd) 
}
 
package BackEndCommands.ControlOperations;
public class DoTimes extends ControlCommand { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.ControlOperations;
public class For extends ControlCommand { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.ControlOperations;
public class If extends ControlCommand { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.ControlOperations;
public class IfElse extends ControlCommand { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.ControlOperations;
public class MakeVariable extends CommandParser implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.ControlOperations;
public class Repeat extends ControlCommand { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.ControlOperations;
public class To extends ControlCommand { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.ControlOperations;
public class Variable implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands;
public class ListEnd implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands;
public class ListStart implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class ArcTangent implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class ATan implements Command { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Cosine implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Difference implements Command { 
  	public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Log implements Command { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Minus implements Command { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class NaturalLog implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Pi implements Command { 
  	public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Power implements Command { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Product implements Command { 
  	public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Quotient implements Command { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Random implements Command { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Remainder implements Command { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Sine implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Sum implements Command { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.MathOperations;
public class Tangent implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands;
public class NoType implements Command { 
      public double executeCommand(List<Double> args) 
    public int numArguments() 
}
 
package BackEndCommands;
public abstract class TurtleCommand implements Command { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
	public void setProperties(ObservableProperties prop) 
}
 
package BackEndCommands.TurtleCommands;
public class Back extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleCommands;
public class ClearScreen extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleCommands;
public class Forward extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleCommands;
public class HideTurtle extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleCommands;
public class Home extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleCommands;
public class Left extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleCommands;
public class PenDown extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleCommands;
public class PenUp extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleCommands;
public class Right extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleCommands;
public class SetHeading extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleCommands;
public class SetXY extends TurtleCommand{ 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleCommands;
public class ShowTurtle extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleCommands;
public class Towards extends TurtleCommand{ 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleQueries;
public class Heading extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleQueries;
public class PenDown extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleQueries;
public class Showing extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleQueries;
public class XCor extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndCommands.TurtleQueries;
public class YCor extends TurtleCommand { 
  	public double executeCommand(List<Double> args) 
	public int numArguments() 
}
 
package BackEndExternalAPI;
public class CommandParser { // TODO DE STATIC EVERYTHING 
      public static HashMap<String, LogoMethod> myMethods = new HashMap<String, LogoMethod>();
    public static HashMap<String, Double> myMethodVariables = new HashMap<String, Double>();
    public HashMap<String, Double> getVariables() 
    public void setProperties(ObservableProperties properties) 
    public double getAction(String command) 
    public void printTree(ParseTreeNode r)  // TODO DEBUGGING
    public double getMyResult()
}
 
package BackEndInternalAPI;
 public interface Command {
  }
 
package BackEndInternalAPI;
public class CommandTypeDetector { 
      public CommandTypeDetector() 
    public Command getCommandObj(String command) 
    public String getCommandType(String command) 
}
 
package BackEndInternalAPI;
public class LogoMethod { 
      public LogoMethod() 
    public void addArgument(String argument) 
    public String getArgument(int index) 
    public int numArguments() 
    public void setMethod(ParseTreeNode newMethod) 
    public ParseTreeNode getMethod() 
}
 
package BackEndInternalAPI;
public class ObservableProperties { 
  	public ObservableProperties(ImageView turtle) 
	public BooleanProperty getNewLineProperty() 
	public BooleanProperty getClearScreenProperty() 
	public BooleanProperty getImageVisibleProperty() 
	public DoubleProperty getRotateProperty() 
	public DoubleProperty getXProperty() 
	public void setXProperty(double value) 
	public double getYProperty() 
	public void setYProperty(double value) 
	public BooleanProperty getPathVisibleProperty() 
}
 
package BackEndInternalAPI;
public class ParseTreeBuilder { 
      public ParseTreeNode initParseTree(String[] commands) 
}
 
package BackEndInternalAPI;
public class ParseTreeExecutor extends CommandParser { 
      public double getVariable(String variable) 
    public void setVariable(String variable, double value) 
    public double executeTree(ParseTreeNode currNode) 
}
 
package BackEndInternalAPI;
public class ParseTreeNode { 
      public double executeCommand(ArrayList<Double> args) 
    public double getValue() 
    public void setValue(Double newValue) 
    public String getCommand() 
    public void setCommand(String newCommand) 
    public String getCommandType() 
    public void setCommandType(String newCommandType) 
    public Command getCommandObj() 
    public void setCommandObj(Command newCommandObj) 
    public void addChild(ParseTreeNode newChild) 
    public ParseTreeNode getChild(int index) 
    public boolean hasChild() 
    public boolean hasNoChildren() 
    public int getNumChildren() 
    public ArrayList<ParseTreeNode> getChildren() 
}
 
package Base;
public abstract class OptionsMenu implements Options { 
      public OptionsMenu (Stage s)
    public Parent setUpWindow()
    public void setParameters() 
    public void setDefaults(Color paint, String background, String turtle, String language)
    public void changeBackground() 
    public void changePenColor() 
    public void changeLanguage() 
    public void changeSpriteImage() 
    public ImageView getChosenTurtle()
    public ImageView getChosenBackground()
    public ColorPicker getPenColor()
    public Pane getStartWindow() 
    public ComboBox<String> getBackgroundBox() 
    public ComboBox<String> getTurtleBox() 
    public ComboBox<String> getLanguageBox() 
    public String getOverButton() 
    public String getButtonFill() 
    public Stage getStage()
    public abstract void addTitle();
    public abstract void addRectangle();
    public abstract void addLaunchButton();
    public abstract void initIDE(String background, String turtle);
}
 
package FrontEndExternalAPI;
 public interface Console {
      public void printResult();
}
 
package FrontEndExternalAPI;
 public interface Editor{
      public String getCurrentText();
}
 
package FrontEndExternalAPI;
 public interface GUIController {
      public void init();
    public void getInitialParams();
    public void getCurrentCommand();
    public void passCurrentCommand();
    public void throwError();
    public void getErrors();
    public void storeOldCommand();
    public void returnAction();
}
 
package FrontEndExternalAPI;
 public interface History {
      public void addCommand(String text);
    public void callCommand(String text);
}
 
package FrontEndExternalAPI;
 public interface StartMenu {
      public void setParameters();
    public void initIDE();
}
 
package FrontEndExternalAPI;
 public interface Variables {
      public void addVariable(String name, double value);
    public ArrayList<Integer> getAllVariables();
}
 
package FrontEndInternalAPI;
 public interface ButtonMenu {
      public Button newButton(String text, int x, int y);
    public void addButtons();
}
 
package FrontEndInternalAPI;
 public interface Options {
      public void changeBackground();
    public void changePenColor();
    public void changeLanguage();
    public void changeSpriteImage();
}
 
package FrontEndInternalAPI;
 public interface RenderSprite {
      public void updateNodes();
    public void updateDisplayOptions();
    public void resetIDE();
}
 
package GUI;
public class CommandHelp extends HelpMenu { 
      public CommandHelp(Stage s) 
    public void addNodes()
    public Text addTip(String text, int x, int y)
}
 
package GUI;
public class ConsoleHelp extends HelpMenu { 
      public ConsoleHelp(Stage s) 
    public void addNodes()
    public Text addTip(String text, int x, int y)
}
 
package GUI;
public class DisplayHelp extends HelpMenu { 
      public DisplayHelp(Stage s) 
    public void addNodes()
    public Text addTip(String text, int x, int y)
}
 
package GUI;
public class EditorHelp extends HelpMenu { 
      public EditorHelp(Stage s) 
    public void addNodes()
    public Text addTip(String text, int x, int y)
}
 
package GUI;
public class GUIButtonMenu implements ButtonMenu{ 
      public GUIButtonMenu(Pane p, Paint borderColor)
    public void addButtons() 
    public Button newButton(String text, int x, int y) 
    public void setDefaults(Color paint, String background, String turtle, String language)
    public OptionsPopup getOptionsPopup()
    public Rectangle getBackdrop()
}
 
package GUI;
public class HelpMenu { 
      public HelpMenu(Stage s)
    public void init()
    public Parent setUpWindow()
    public void addNodes()
    public Button addButton(String text, int x, int y)
    public Rectangle addRectangle()
    public Stage getStage()
    public Pane getWindow()
}
 
package GUI;
public class HistoryHelp extends HelpMenu { 
      public HistoryHelp(Stage s) 
    public void addNodes()
    public Text addTip(String text, int x, int y)
}
 
package GUI;
public class OptionsPopup extends OptionsMenu { 
      public OptionsPopup(Stage s, Color penColor, String background, String turtle, String language)
    public void initPopup()
    public void addTitle() 
    public void addRectangle() 
    public void addLaunchButton() 
    public void initIDE(String background, String turtle) 
}
 
package GUI;
public class VariablesHelp extends HelpMenu { 
      public VariablesHelp(Stage s) 
    public void addNodes()
    public Text addTip(String text, int x, int y)
}
 
package GUIController;
public class GUIConsole implements Console{ 
      public GUIConsole(Pane p, Paint borderColor)
    public void addConsole(String text) 
    public void printResult() 
}
 
package GUIController;
public class GUIDisplay implements RenderSprite { 
      public GUIDisplay(Pane p, ImageView turtle, Paint pathColor)
    public void bindNodes(ReadOnlyDoubleProperty width)
    public void moveTurtle(int x, int y)
    public void drawNewLine(BooleanProperty bool )
    public void drawNewLine(Point origin, Point destination)
	public void clearScreen(BooleanProperty clearScreenProperty) 
    public void setVisibility(boolean isVisible)
    public ImageView getGraph()
    public Point getTurtleLocation()
    public void updateNodes() 
    public void updateDisplayOptions() 
    public void resetIDE() 
}
 
package GUIController;
public class GUIEditor implements Editor { 
      public GUIEditor(Pane p, Paint borderColor) 
    public Rectangle getBackdrop()
    public void startNewCommand()
    public void bindNodes(ReadOnlyDoubleProperty width, ReadOnlyDoubleProperty height)
    public String getCurrentText() 
    public void redoCommand(String str) 
}
 
package GUIController;
public class GUIHistory implements History { 
      public GUIHistory(Pane p, Paint bordercoloir)
    public Rectangle getBackdrop()
    public void addCommand(String text) 
    public void callCommand(String str) 
    public String getRedoCommand()
}
 
package GUIController;
public class GUIManager implements GUIController { 
      public GUIManager(Color penColor, String background, String turtle, String language) 
    public void init() 
    public void getInitialParams() 
    public void getCurrentCommand() 
    public void passCurrentCommand() 
    public void throwError() 
    public void getErrors() 
    public void storeOldCommand() 
    public void returnAction() 
}
 
package GUIController;
public class GUIStartMenu extends OptionsMenu { 
      public GUIStartMenu(Stage s) 
    public void addTitle() 
    public void addLaunchButton()
    public void addRectangle()
    public void initIDE(String chosenBackground, String chosenTurtle) 
        public BigNameText(String Name) 
}
 
package GUIController;
public class GUIVariables implements Variables {     public static class Variable { 
      public GUIVariables(Pane p, Paint bodercolor)
                    public void handle(CellEditEvent<Variable, String> t) 
                    public void handle(CellEditEvent<Variable, Double> t) 
    public void addVariable(String name, double value) 
    public ArrayList<Integer> getAllVariables() 
        public String getVariableName() 
        public void setVariableName(String fName) 
        public double getVariableValue() 
        public void setVariableValue(double fName) 
}
 
package Main;
public class Main extends Application { 
      public void start(Stage primaryStage) 
}