UI

java.lang.Object
- ecs100.UI

```
public class UI
extends java.lang.Object
```
The UI class provides a simple, flexible Graphical User Interface suitable for small programs. The UI class will construct a window which can contain
- a menu at the top (with commands for turning the Trace facility on and off, clearing the text and graphics pane, and quitting.
- a text output pane which can display text output, and read text input.
- a graphics output pane which can display graphical output (anything output using the draw... methods). The user can also use the mouse and key strokes in this region.
- an input panel which can contain buttons, textfields, and sliders.
- a message line at the bottom for short messages to the user.
The input panel will only be displayed if it is used - if your program doesn't have any buttons etc, then only the text and graphics panes will be visible.
UI provides methods for:
- printing and reading from the text pane, including methods for asking the user for a single value.
- drawing shapes on the graphics pane. The shapes include lines, rectangles, ovals, strings, arcs, polygons, and images. They can be drawn in outline, filled in, erased, or inverted. The redrawing is normally immediate, but can be delayed and all the changes redrawn at once.
  Note:Inverting a shape will draw an outline of the shape, but instead of painting with the current paint colour, it "inverts" the color of the pixels underneath the outline in a way that inverting a second time will restore the original color.
- placing buttons, textfields and sliders on the input panel.
- setting the mouseListener and keyListener for the graphics pane.
- miscellaneous useful things like pausing (sleep) and quitting.
Remember: Clicking on a method below jumps to more complete documentation.

Method Summary

Text Output
Modifier and Type	Method and Description
`static void`	`clearText()` Clear the contents of the text output region.
`static void`	`print(anything value)` Print a value to the text pane.
`static void`	`printf(String format, Object... args)` The `printf()` method requires a format string (which will contain "holes" specified with %'s) and additional arguments which will be placed "in the holes", using the specified formatting.
`static void`	`println()` Start a new line on the text pane.
`static void`	`println(anything value)` Print a value to the text pane and start a new line.
`static void`	`printMessage(String s)` Print a message to the message line.

Prompted text input (Ask...)
Modifier and Type	Method and Description
`static String`	`askString(String question)` Ask the user for a string.
`static double`	`askDouble(String question)` Ask the user for a number.
`static int`	`askInt(String question)` Ask the user for an integer.
`static boolean`	`askBoolean(String question)` Ask the user for a boolean value.
`static String`	`askToken(String question)` Ask the user for a single token.
`static ArrayList<Double>`	`askNumbers(String question)` Ask the user for a list of numbers.
`static ArrayList<String>`	`askStrings(String question)` Ask the user for a list of strings.

General Text input
Modifier and Type	Method and Description
`static String`	`next()` Read and return the next token of the user's input.
`static boolean`	`nextBoolean()` Read the next token of the user's input. Return true if it is "yes", "y", or "true", return false if it is "no", "n", or "false" (case insensitive). Throws an exception if it is anything else.
`static double`	`nextDouble()` Read the next token of the user's input. Return it as a double if it is a number. Throws an exception if it is not a number.
`static int`	`nextInt()` Read the next token of the user's input. Return it as an int if it is an integer. Throws an exception if it is not an integer.
`static String`	`nextLine()` Read the remaining characters of the user's input up to (but not including) the next end-of-line and return them as a string. Reads and throws away the end-of-line character. If there are no characters on the line, then it returns an empty string ("").
`static boolean`	`hasNext()` Returns true, but waits for the user to type something if necessary.
`static boolean`	`hasNextBoolean()` Returns true if the next token in the user input is "yes", "true", "no" or "false'". Waits for the user to type something if necessary.
`static boolean`	`hasNextDouble()` Returns true if the next token in the user input is a number. Waits for the user to type something if necessary.
`static boolean`	`hasNextInt()` Returns true if the next token in the user input is an integer. Waits for the user to type something if necessary.
`static boolean`	`hasNextLine()` Returns true, but waits for the user to type something if necessary.

Drawing on the Graphics Pane
Modifier and Type	Method and Description
`static void`	`clearGraphics()` Clear the contents of the graphics output region.
`static void`	`setColor(java.awt.Color col)` Set the color of the brush in the graphics output region. This will be the color of any shapes drawn after this. See the Color class for how to specify a color.
`static void`	`setFontSize(double size)` Set the point size of the Font of String to be drawn in the graphics output region. This will be the size of the font of any String drawn after this.
`static void`	`setLineWidth(double width)` Set the width of the lines (in pixels) for lines drawn in the graphics output region. This will be the width of lines drawn with drawLine and the outlines of shapes drawn after this.
`static void`	`setImmediateRepaint(boolean immediate)` Set the "immediate repaint" status of the UI drawing commands. If the status is true (the default), then all the draw, fill, erase, invert methods will have an immediately visible effect. This is the simplest way of drawing If the status is false, then all the draw, fill, erase, invert methods will draw in the background, but will not update the graphics pane so that the effect will not be immediately visible. To show all the changes on the graphics pane, the program should call the repaintGraphics method (below). Setting immediate repaint to false allows faster and smoother animation, but is more complicated because the program must call repaintGraphics at the right time.
`static void`	`repaintGraphics()` Repaint the contents of the graphics output region. Used after drawing shapes if immediateRepaint was set to be false.
`static void`	`drawLine(double x1, double y1, double x2, double y2)` `eraseLine(double x1, double y1, double x2, double y2)` `invertLine(double x1, double y1, double x2, double y2)` Draw/erase/invert a line in the graphics output region from (`x1`, `y1`) to (`x2`, `y2`).
`static void`	`drawRect(double left, double top, double width, double height)` `fillRect(double left, double top, double width, double height)` `eraseRect(double left, double top, double width, double height)` `invertRect(double left, double top, double width, double height)` Draw/fill/erase/invert a rectangle in the graphics output region. `left` and `top` specify the position of the top left corner of the rectangle, and `width` and `height` specify its size.
`static void`	`drawOval(double left, double top, double width, double height)` `fillOval(double left, double top, double width, double height)` `eraseOval(double left, double top, double width, double height)` `invertOval(double left, double top, double width, double height)` Draw/fill/erase/invert an oval in the graphics output region. `left` and `top` specify the left edge and the top of the oval; `width` and `height` specify the size of the oval.
`static void`	`drawString(String s, double x, double y)` `eraseString(String s, double x, double y)` `invertString(String s, double x, double y)` Draw/erase/invert the given string in the graphics output region at the position (left, baseline).
`static void`	`drawArc(double left, double top, double width, double height, double startAngle, double arcAngle)` `fillArc(double left, double top, double width, double height, double startAngle, double arcAngle)` `eraseArc(double left, double top, double width, double height, double startAngle, double arcAngle)` `invertArc(double left, double top, double width, double height, double startAngle, double arcAngle)` Draw/fill/erase/invert an arc in the graphics output region. An arc is a segment of an oval. The first four parameters (`left, top, width, height`) specify the left, top and size of the whole oval. `startAngle` and `arcAngle` specify which segment of the oval will be drawn: the arc starts at `startAngle` degrees (measured anti-clockwise from the x axis 0 degrees), and extends anti-clockwise for `arcAngle` degrees from the startAngle. A filled arc will be "pie-shaped" - bounded by the arc and two lines from each end of the arc to the center of the oval.
`static void`	`drawImage(String fileName, double left, double top)` `drawImage(String fileName, double left, double top, double width, double height)` `drawImage(java.awt.Image img, double left, double top)` `drawImage(java.awt.Image img, double left, double top, double width, double height)` Draw an image at the position (left,top). The image can be specified as the name of a file containing the image or as an Image object. With the additional arguments, width and height, scale the image to these dimensions.
`static void`	`eraseImage(String fileName, double left, double top)` `eraseImage(java.awt.Image img, double left, double top)` Erase an image at the position (left, top). The image can be specified as the name of a file containing the image or as an Image object. Note, if the image was scaled, the image can be erased using eraseRect(left, top, width, height)
`static void`	`drawPolygon(double[] xPoints, double[] yPoints, int nPoints)` `fillPolygon(double[] xPoints, double[] yPoints, int nPoints)` `erasePolygon(double[] xPoints, double[] yPoints, int nPoints)` `invertPolygon(double[] xPoints, double[] yPoints, int nPoints)` Draw/fill/erase/invert a polygon in the graphics output region. The polygon is specified by two arrays containing the x coordinates and the y coordinates of the series of vertices of the polygon, and the number of vertices.

Buttons, TextFields, Sliders, Mouse and Keys
Modifier and Type	Method and Description
`static javax.swing.JButton`	`addButton(String name, UIButtonListener action)` Add a button to the input panel on the left side of the gui window. `action` must be a function with no parameters.
`static void`	`addSlider(String s, double min, double max, ecs100.UISliderListener action)` `addSlider(String s, double min, double max, double initial, UISliderListener action)` Add a slider to the input panel on the left side of the gui window. Must specify the name, and the minimum and maximum values of the slider. You may also specify the initial value. Note that the slider only returns integer values, so a range 0 to 10 works (with 10 possible values for the slider), but a range of 0 to 1 won't work, because there is only one possible value. `action` must be a function with one parameter - a double.
`static void`	`addTextField(String s, UITextFieldListener action)` Add a text field to the input panel on the left side of the gui window. `action` must be a function with one String parameter.
`static void`	`setMouseListener(UIMouseListener action)` Enable the user to use the mouse on the graphics pane, recognising presses, releases, and clicks. `action` must be a function with three parameters - a String, and two doubles.
`static void`	`setMouseMotionListener(UIMouseListener action)` Enable the user to use the mouse on the graphics pane, recognising drags and moves, in addition to presses, releases, and clicks. `action` must be a function with three parameters - a String, and two doubles.
`static void`	`setKeyListener(UIKeyListener action)` Enable the user to press keys for intput on the graphics pane. `action` must be a function with one String parameter.

Other
Modifier and Type	Method and Description
`static void`	`initialise()` Ensure that the UI window is initialised
`static void`	`sleep(double millis)` Causes the program to pause for a specified number of milliseconds.
`static void`	`quit()` Get rid of the interface windows, which will usually halt the program.
`static void`	`clearPanes()` Clear both the text pane and the graphics pane
`static void`	`setWindowSize(int width, int height)` Sets the width and height of the text and graphics area.
`static void`	`setDivider(double position)` Move the divider between the text and graphics panes to the specified fraction. The value of `position` should be between 0.0 (at the left side - only graphics visible) and 1.0 (at right side - only text visible). A negative value means put it at the initial default position. This should be called after all the buttons etc have been added and the size of the text and graphics area has been set.
`static javax.swing.JFrame`	`getFrame()` Return the JFrame of the UI window. Only needed if you want to do more complicated stuff.
`static java.awt.Graphics2D`	`getGraphics()` Return the Graphics2D object underlying the graphics pane. Only needed if you want to do more complicated operations on the graphics pane than are provided by methods in this UI class.
`static void`	`repaintAllGraphics()` Repaint all the contents of the graphics output region. Ignores the "dirty" marker.
`static int`	`getCanvasHeight()` `getCanvasWidth()` Returns the height or the width of the canvas in the graphics pane. Note, this is the size of the actual drawing area, not necessarily the part of it that is currently visible in the window. Changing the size of the window will not change the size of the canvas, it only changes how much of it is visible.

- Method Detail
  - initialise
```
public static void initialise()
```
    Ensure that the User Interface window is initialised
  - clearGraphics
```
public static void clearGraphics()
```
    Clear the contents of the graphics output region.
  - repaintGraphics
```
public static void repaintGraphics()
```
    Repaint the contents of the graphics output region.
  - setColor
```
public static void setColor(java.awt.Color col)
```
  - setForeGround
```
public static void setForeGround(java.awt.Color col)
```
  - setFontSize
```
public static void setFontSize(double size)
```
  - setLineWidth
```
public static void setLineWidth(double width)
```
  - drawLine
```
public static void drawLine(double x1,
            double y1,
            double x2,
            double y2)
```
    Draw a line in the graphics output region from (x1, y1) to (x2, y2).
  - eraseLine
```
public static void eraseLine(double x1,
             double y1,
             double x2,
             double y2)
```
    Erase the line in the graphics output region from (x1, y1) to (x2, y2).
  - invertLine
```
public static void invertLine(double x1,
              double y1,
              double x2,
              double y2)
```
    Inverting a line will draw the line by "inverting" the color of the pixels underneath the outline in a way that inverting a second time will restore the original color.
  - drawRect
```
public static void drawRect(double x,
            double y,
            double width,
            double height)
```
    Draw the outline of a rectangle in the graphics output region with a top-left corner at (x, y) and of the specified width and height.
  - fillRect
```
public static void fillRect(double x,
            double y,
            double width,
            double height)
```
    Draw a solid rectangle in the graphics output region with a top-left corner at (x, y) and of the specified width and height.
  - eraseRect
```
public static void eraseRect(double x,
             double y,
             double width,
             double height)
```
    Erase the rectangular region in the graphics output region with a top-left corner at (x, y) and of the specified width and height.
  - invertRect
```
public static void invertRect(double x,
              double y,
              double width,
              double height)
```
    Invert the rectangular region in the graphics output region with a top-left corner at (x, y) and of the specified width and height.
    Inverting a rectangle will draw the rectangle by "inverting" the color of the pixels underneath the outline in a way that inverting a second time will restore the original color.
  - drawString
```
public static void drawString(String s,
              double x,
              double y)
```
    Draw the given string in the graphics output region at the position (x, y) .
  - drawString
```
public static void drawString(String s,
              double x,
              double y,
              boolean redraw)
```
  - eraseString
```
public static void eraseString(String s,
               double x,
               double y)
```
    Erase the region covered given string in the graphics output region at the position (x, y).
  - invertString
```
public static void invertString(String s,
                double x,
                double y)
```
    Invert the pixels of the string in the graphics output region at the position (x, y) in a way that inverting a second time will restore the original color.
  - drawOval
```
public static void drawOval(double x,
            double y,
            double width,
            double height)
```
    Draw the outline of an oval in the graphics output region with the left edge of the oval at x, the top of the oval at y, and having the specified width and height.
  - fillOval
```
public static void fillOval(double x,
            double y,
            double width,
            double height)
```
    Draw a solid oval in the graphics output region with the left edge of the oval at x, the top of the oval at y, and having the specified width and height.
  - eraseOval
```
public static void eraseOval(double x,
             double y,
             double width,
             double height)
```
    Erase an oval region in the graphics output region with the left edge of the oval at x, the top of the oval at y, and having the specified width and height.
  - invertOval
```
public static void invertOval(double x,
              double y,
              double width,
              double height)
```
    Invert an oval region in the graphics output region with the left edge of the oval at x, the top of the oval at y, and having the specified width and height.
    Inverting an oval will draw the oval by "inverting" the color of the pixels underneath the outline in a way that inverting a second time will restore the original color.
  - drawArc
```
public static void drawArc(double x,
           double y,
           double width,
           double height,
           double startAngle,
           double arcAngle)
```
    Draw the outline of an arc in the graphics output region. An arc is a segment of an oval, and is specified by giving the left edge of the oval (x), the top of the oval (y), the width and height of the oval, and the angle (anticlockwise from the x-axis) that the arc starts, and the angle of the arc.
  - fillArc
```
public static void fillArc(double x,
           double y,
           double width,
           double height,
           double startAngle,
           double arcAngle)
```
    Draw a solid arc in the graphics output region. An arc is a segment of an oval, and is specified by giving the left edge of the oval (x), the top of the oval (y), the width and height of the oval, and the angle (anticlockwise from the x-axis) that the arc starts, and the angle of the arc.
  - eraseArc
```
public static void eraseArc(double x,
            double y,
            double width,
            double height,
            double startAngle,
            double arcAngle)
```
    Erase an arc-shaped region of the graphics output region. An arc is a segment of an oval, and is specified by giving the left edge of the oval (x), the top of the oval (y), the width and height of the oval, and the angle (anticlockwise from the x-axis) that the arc starts, and the angle of the arc.
  - invertArc
```
public static void invertArc(double x,
             double y,
             double width,
             double height,
             double startAngle,
             double arcAngle)
```
    Invert an arc-shaped region of the graphics output region. An arc is a segment of an oval, and is specified by giving the left edge of the oval (x), the top of the oval (y), the width and height of the oval, and the angle (anticlockwise from the x-axis) that the arc starts, and the angle of the arc.
    Inverting an arc will draw the arc by "inverting" the color of the pixels underneath the outline in a way that inverting a second time will restore the original color.
  - drawImage
```
public static void drawImage(String fileName,
             double x,
             double y,
             double width,
             double height)
```
    Draw an image in the graphics output region. The image may be specified by giving a file name, or providing the Image object. The 2nd and 3rd arguments are where the left, top corner of the image should be placed. Optional 4th and 5th arguments are the width and height to scale the image; if not provided, the image will have its natural size.
  - drawImage
```
public static void drawImage(String fileName,
             double x,
             double y)
```
  - drawImage
```
public static void drawImage(java.awt.Image img,
             double x,
             double y,
             double width,
             double height)
```
  - drawImage
```
public static void drawImage(java.awt.Image img,
             double x,
             double y)
```
  - eraseImage
```
public static void eraseImage(String fileName,
              double x,
              double y)
```
    Erase an unscaled image, specified by a file name or an Image object.
    (To erase a scaled image, erase the rectangular region that the image was scaled to.)
  - eraseImage
```
public static void eraseImage(java.awt.Image img,
              double x,
              double y)
```
  - drawPolygon
```
public static void drawPolygon(double[] xPoints,
               double[] yPoints,
               int nPoints)
```
    Draw the outline of an polygon in the graphics output region. The polygon is specified by two arrays containing the x coordinates and the y coordinates of the series of vertices of the polygon, and the number of vertices.
  - fillPolygon
```
public static void fillPolygon(double[] xPoints,
               double[] yPoints,
               int nPoints)
```
    Draw a filled polygon in the graphics output region. The polygon is specified by two arrays containing the x coordinates and the y coordinates of the series of vertices of the polygon, and the number of vertices.
  - erasePolygon
```
public static void erasePolygon(double[] xPoints,
                double[] yPoints,
                int nPoints)
```
    Erase an polygon region in the graphics output region. The polygon is specified by two arrays containing the x coordinates and the y coordinates of the series of vertices of the polygon, and the number of vertices.
  - invertPolygon
```
public static void invertPolygon(double[] xPoints,
                 double[] yPoints,
                 int nPoints)
```
    Invert an polygon region in the graphics output region. The polygon is specified by two arrays containing the x coordinates and the y coordinates of the series of vertices of the polygon, and the number of vertices.
    Inverting a polygon will draw the polygon by "inverting" the color of the pixels underneath the outline in a way that inverting a second time will restore the original color.
  - clearText
```
public static void clearText()
```
    Clear the contents of the text output region.
  - print
```
public static void print(String s)
```
    Print a String to the text pane.
  - print
```
public static void print(boolean b)
```
    Print a boolean to the text pane.
  - print
```
public static void print(char c)
```
    Print a character to the text pane.
  - print
```
public static void print(double d)
```
    Print a number to the text pane.
  - print
```
public static void print(int i)
```
    Print an integer to the text pane.
  - print
```
public static void print(Object o)
```
    Print an object to the text pane. Note, it calls the toString() method on the object, and prints the result. This may or may not be useful.
  - println
```
public static void println()
```
    Start a new line on the text pane.
  - println
```
public static void println(String s)
```
    Print a string to the text pane and start a new line.
  - println
```
public static void println(boolean b)
```
    Print a boolean to the text pane and start a new line.
  - println
```
public static void println(char c)
```
    Print a character to the text pane and start a new line.
  - println
```
public static void println(double d)
```
    Print a number to the text pane and start a new line.
  - println
```
public static void println(int i)
```
    Print an integer to the text pane and start a new line.
  - println
```
public static void println(Object o)
```
    Print an object to the text pane and start a new line. Note, it calls the toString() method on the object, and prints the result. This may or may not be useful.
  - printf
```
public static void printf(String format,
          Object... args)
```
    The printf() method requires a format string (which will contain "holes" specified with %'s) and additional arguments which will be placed "in the holes", using the specified formatting.
  - askToken
```
public static String askToken(String question)
```
    Prints the question and waits for the user to answer. Returns the first token in their answer as a String. Removes any pending user input before asking the question.
  - askString
```
public static String askString(String question)
```
    Prints the question and waits for the user to answer. Returns their answer as a String. Removes any pending user input before asking the question.
  - askInt
```
public static int askInt(String question)
```
    Prints the question and waits for the user to answer with an integer. Returns their answer as an int. Removes any pending user input before asking the question.
  - askDouble
```
public static double askDouble(String question)
```
    Prints the question and waits for the user to answer with a number. Returns their answer as a double. Removes any pending user input before asking the question.
  - askBoolean
```
public static boolean askBoolean(String question)
```
    Prints the question and waits for the user to answer with yes/no or true/false. Returns their answer as a boolean. Removes any pending user input before asking the question.
  - askNumbers
```
public static ArrayList<Double> askNumbers(String question)
```
    Prints the question and waits for the user to enter a list of numbers. User must enter one number per line, ending with the token 'done'. Returns their answer as an ArrayList of Double. Removes any pending user input before asking the question.
  - askStrings
```
public static ArrayList<String> askStrings(String question)
```
    Prints the question and waits for the user to enter a list of strings. User must enter one String per line, ending with a blank line. Returns their answer as an ArrayList of Strings. Removes any pending user input before asking the question.
  - next
```
public static String next()
```
    Read the next token of the user's input and return it. Waits for user input if there isn't any yet.
  - nextInt
```
public static int nextInt()
```
    Read the next token of the user's input and return it as an int if it is an integer. Throws an exception if it is not an integer. Waits for user input if there isn't any yet.
  - nextDouble
```
public static double nextDouble()
```
    Read the next token of the user's input and return it as a double if it is a number. Throws an exception if it is not a number. Waits for user input if there isn't any yet.
  - nextBoolean
```
public static boolean nextBoolean()
```
    Read the next token of the user's input and return true if it is "yes", "y", or "true", return false if it is "no", "n", or "false" (case insensitive). Throws an exception if it is anything else. Waits for user input if there isn't any yet.
  - nextLine
```
public static String nextLine()
```
    Read the remaining characters of the user's input up to (but not including) the next end-of-line and return them as a string. Reads and throws away the end-of-line character. If there are no characters on the line, then it returns an empty string (""). Waits for user input if there isn't any yet.
  - hasNext
```
public static boolean hasNext()
```
    Returns true if there is any user input, but waits for the user to type something if there isn't any yet. (ie, always returns true).
  - hasNextInt
```
public static boolean hasNextInt()
```
    Returns true if the next token in the user input is an integer. waits for the user to type something if there isn't any yet.
  - hasNextDouble
```
public static boolean hasNextDouble()
```
    Returns true if the next token in the user input is a number. waits for the user to type something if there isn't any yet.
  - hasNextBoolean
```
public static boolean hasNextBoolean()
```
    Returns true if the next token in the user input is a yes/no or true/false. waits for the user to type something if there isn't any yet.
  - hasNextLine
```
public static boolean hasNextLine()
```
    Returns true if there is any user input, but waits for the user to type something if there isn't any yet. (ie, always returns true).
  - printMessage
```
public static void printMessage(String s)
```
    Print a message to the message line.
  - addButton
```
public static javax.swing.JButton addButton(String name,
             ecs100.UIButtonListener action)
```
    Add a button to the input panel on the left side of the gui window. The first argument is the name that should appear on the button. The second argument is the action to perform when the button is clicked. action must have no parameters.
    The action can be a method to call, eg UI::clearPanes or this::doit.
    Or, the action can be a simple "lambda": eg () -> this.size = 5, or a more complicated "lambda": eg () -> { this.doit(); this.size = 5; }
    addButton returns the new button, in case you want to change the color or name of the button later.
  - addTextField
```
public static void addTextField(String s,
                ecs100.UITextFieldListener action)
```
    Add a text field to the input panel on the left side of the gui window.
    A text field allows the user to enter a string value by typing the string into the field.
    The first argument is the label that the text field will be given. The second argument is the action to perform when a value is entered in the text field. action must have one String parameter.
    The action can be a method (with one String parameter) to call, eg this::processName,
    Or, the action can be a simple "lambda": eg (String v) -> this.name = v, or a more complicated "lambda": eg (String v) -> { this.name = v; UI.clearText(); this.listDetails(); }
  - addSlider
```
public static void addSlider(String s,
             double min,
             double max,
             ecs100.UISliderListener action)
```
    Add a slider to the input panel on the left side of the gui window.
    A slider allows the user to enter a numeric value by moving the slider knob along the slider.
    The arguments are the name of the slider, the minimum and maximum vales of the slider (integers) and the action to perform when a value is set with the slider. action must have one double parameter.
    The action can be a method (with one double parameter) to call, eg this::resetSize,
    Or, the action can be a simple "lambda": eg (double v) -> this.size = v, or a more complicated "lambda": eg (double v) -> { this.reset(); this.size = v; UI.redraw(); }
  - addSlider
```
public static void addSlider(String s,
             double min,
             double max,
             double initial,
             ecs100.UISliderListener action)
```
  - setKeyListener
```
public static void setKeyListener(ecs100.UIKeyListener action)
```
    Enable the UI to notice key events when the mouse is over the graphics pane. The program will respond to keys being typed (pressed and then released), not to the presses and releases separately. The argument is the action to perform when a key is typed. action must have one String parameter.
    The action can be a method (with one String parameter) to call, eg this::recordKey,
    Or, the action can be a simple "lambda": eg (String v) -> this.setLastKey(v), or a more complicated "lambda": eg (String v) -> { if (v.equals("Up")) {this.moveUp();} else {this.moveDown(); }
    The action will be passed a string specifying the key that the user typed, eg "A", "x", "+", "HOME", etc
  - setMouseListener
```
public static void setMouseListener(ecs100.UIMouseListener action)
```
    Enable the user to use the mouse on the graphics pane on the right side of the gui window. The program will respond to the user
    - pressing the mouse button,
    - releasing the mouse button
    - clicking the mouse button (pressing and releasing without moving)
    but will not notice movements of the mouse.
    The argument is the action to respond to the mouse. action must have three parameters: a String (the kind of mouse event), and two doubles (the x and y coordinates where the event happened).
    Typically, the action will be this::doMouse, where doMouse is a method with the header
```
     public void doMouse(String action, double x, double y)
```
    which will be passed three values:
    - a string specifying what the user did: "pressed", "released" or "clicked"
    - the coordinates (two doubles) of the mouse when the event happened.
    Note also that if the user clicks the mouse there will be three events - a "pressed", a "released", and a "clicked".
  - setMouseMotionListener
```
public static void setMouseMotionListener(ecs100.UIMouseListener listener)
```
    Enable the user to use the mouse on the graphics pane on the right side of the gui window. This is identical to the setMouseListener() method (see above) except that the program will also respond to the user
    - moving the mouse (moving it with the button up), and
    - dragging the mouse (moving it with the button down)
    The argument is the action to respond to the mouse. action must have three parameters: a String (the kind of mouse event), and two doubles (the x and y coordinates where the event happened).
    Typically, the action will be this::doMouse, where doMouse is a method with the header
```
     public void doMouse(String action, double x, double y)
```
    which will be passed three values:
    - a string specifying what the user did: "pressed", "released", "clicked", "moved" or "dragged"
    - the coordinates (two doubles) of the mouse when the event happened.
  - sleep
```
public static void sleep(double millis)
```
    Causes the program to pause for a specified number of milliseconds. This is useful to control graphical animations - do a sleep between consecutive draw... methods to control the speed of the animation.
  - quit
```
public static void quit()
```
    Get rid of the interface windows. If these are the only open windows, then the program should quit
  - clearPlanes
```
public static void clearPanes()
```
    Clear both the text pane and the graphics pane.
  - setWindowSize
```
public static void setWindowSize(int width, int height)
```
    Sets the width and height of the window.
    Note that adding buttons, sliders, etc may overrule this setting. This should usually be called after all the buttons etc have been added.
  - setDivider
```
public static void setDivider(double position)
```
    Move the divider between the text and graphics panes to the specified fraction. The value of position should be between 0.0 (at the left side - only graphics visible) and 1.0 (at right side - only text visible). A negative value means the initial default position.
  - getFrame
```
public static javax.swing.JFrame getFrame()
```
    Return the JFrame of the UI window. Only needed if you want to do more complicated operations on the graphics pane than are provided by methods in this UI class.
  - getGraphics
```
public static java.awt.Graphics2D getGraphics()
```
    Return the Graphics2D object underlying the graphics pane. Only needed if you want to do more complicated operations on the graphics pane than are provided by methods in this UI class.
  - getCanvasHeight
```
public static int getCanvasHeight()
```
    Returns the height of the canvas in the graphics pane. Note, this is the size of the actual drawing area, not necessarily the part of it that is currently visible in the window.
  - getCanvasWidth
```
public static int getCanvasWidth()
```
    Returns the width of the canvas in the graphics pane. Note, this is the size of the actual drawing area, not necessarily the part of it that is currently visible in the window.

Class UI

Method Summary

Method Detail

initialise

clearGraphics

repaintGraphics

setColor

setForeGround

setFontSize

setLineWidth

drawLine

eraseLine

invertLine

drawRect

fillRect

eraseRect

invertRect

drawString

drawString

eraseString

invertString

drawOval

fillOval

eraseOval

invertOval

drawArc

fillArc

eraseArc

invertArc

drawImage

drawImage

drawImage

drawImage

eraseImage

eraseImage

drawPolygon

fillPolygon

erasePolygon

invertPolygon

clearText

print

print

print

print

print

print

println

println

println

println

println

println

println

printf

askToken

askString

askInt

askDouble

askBoolean

askNumbers

askStrings

next

nextInt

nextDouble

nextBoolean

nextLine

hasNext

hasNextInt

hasNextDouble

hasNextBoolean

hasNextLine

printMessage

addButton

addTextField

addSlider

addSlider

setKeyListener

setMouseListener

setMouseMotionListener

sleep