Implemented observer and strategy pattern in BoatAnnotations, now renamed AnnotationsBox.

Also implemented various other small fixes and further refactored code.

#refactor

src/main/java/seng302/visualiser/fxObjects/AnnotationBox.java

@@ -0,0 +1,185 @@
+package seng302.visualiser.fxObjects;
+
+import java.util.HashMap;
+import java.util.Map;
+import javafx.beans.value.ObservableValue;
+import javafx.scene.CacheHint;
+import javafx.scene.Group;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.text.Text;
+
+/**
+ * Grouping of string objects over a semi transparent background.
+ */
+public class AnnotationBox extends Group{
+
+    @FunctionalInterface
+    public interface AnnotationFormatter<T> {
+        String transformString (T input);
+    }
+
+    /**
+     * Class stores a text object and relationship for updating the text object if needed
+     *
+     * @param <T> The type of observable value passed to the annotation, if there is one.
+     */
+    public class Annotation<T> {
+        private Text text;
+        private ObservableValue<T> source;
+        private AnnotationFormatter<T> format;
+
+        /**
+         * Constructor for observing annotation
+         * @param textObject the javaFX text object the annotation is displayed in
+         * @param source observable value that the annotation is taken from
+         * @param formatter interface describing how to format the source data if needed
+         */
+        public Annotation (Text textObject, ObservableValue<T> source, AnnotationFormatter<T> formatter) {
+            this.text = textObject;
+            this.source = source;
+            this.format = formatter;
+            source.addListener((obs, oldVal, newVal) ->
+                text.setText(format.transformString(newVal))
+            );
+        }
+
+        /**
+         * Constructor for a static annotation
+         * @param textObject the javaFX text object the annotation is displayed in
+         * @param annotationText the static value of the test object
+         */
+        public Annotation (Text textObject, String annotationText) {
+            textObject.setText(annotationText);
+            text = textObject;
+        }
+
+        private Text getText () {
+            return text;
+        }
+    }
+
+    //Text offset constants
+    private static final double X_OFFSET_TEXT = 18d;
+    private static final double Y_OFFSET_TEXT_INIT = -29d;
+    private static final double Y_OFFSET_PER_TEXT = 12d;
+    //Background constants
+    private static final double TEXT_BUFFER = 3;
+    private static final double BACKGROUND_X = X_OFFSET_TEXT - TEXT_BUFFER;
+    private static final double BACKGROUND_Y = Y_OFFSET_TEXT_INIT - TEXT_BUFFER;
+    private static final double BACKGROUND_H_PER_TEXT = 9.5d;
+    private static final double BACKGROUND_ARC_SIZE = 10;
+
+    private int visibleAnnotations = 0;
+    private double backgroundWidth = 125d;
+
+    private Rectangle background = new Rectangle();
+    private Paint theme = Color.BLACK;
+
+    private Map<String, Annotation> annotationsByName = new HashMap<>();
+
+    public AnnotationBox() {
+        this.setCache(true);
+        background.setX(BACKGROUND_X);
+        background.setY(BACKGROUND_Y);
+        background.setWidth(backgroundWidth);
+        background.setHeight(Math.abs(BACKGROUND_X) + TEXT_BUFFER + BACKGROUND_H_PER_TEXT * 4);
+        background.setArcHeight(BACKGROUND_ARC_SIZE);
+        background.setArcWidth(BACKGROUND_ARC_SIZE);
+        background.setFill(new Color(1, 1, 1, 0.75));
+        background.setStroke(theme);
+        background.setStrokeWidth(2);
+        background.setCache(true);
+        background.setCacheHint(CacheHint.SPEED);
+        this.getChildren().add(background);
+    }
+
+    public void addAnnotation (String annotationName, Annotation annotation) {
+        annotationsByName.put(annotationName, annotation);
+        this.getChildren().add(annotation.getText());
+        visibleAnnotations++;
+    }
+
+    public void addAnnotation (String annotationName, String annotationText) {
+        Text text = getTextObject();
+        annotationsByName.put(annotationName, new Annotation(text, annotationText));
+    }
+
+    public <E> void addAnnotation (String annotationName, ObservableValue<E> observable) {
+        addAnnotation(annotationName, observable, E::toString);
+    }
+
+    public <E> void addAnnotation (String annotationName, ObservableValue<E> observable,
+        AnnotationFormatter<E> formatter) {
+        Text newText = getTextObject();
+        annotationsByName.put(annotationName, new Annotation<>(newText, observable, formatter));
+        this.getChildren().add(newText);
+        visibleAnnotations++;
+    }
+
+    public void setAnnotationVisibility (String annotationName, boolean visibility) {
+        Text textField = annotationsByName.get(annotationName).text;
+        boolean currentState = textField.visibleProperty().get();
+
+        if (visibility != currentState) {
+            if (visibility)
+                visibleAnnotations++;
+            else
+                visibleAnnotations--;
+        }
+        textField.setVisible(visibility);
+        update();
+    }
+
+    public void removeAnnotation (String annotationName) {
+        this.getChildren().remove(annotationsByName.remove(annotationName).getText());
+        annotationsByName.remove(annotationName);
+        visibleAnnotations--;
+        update();
+    }
+
+    public void bindLocation () {
+
+    }
+
+    public void setLocation (double x, double y) {
+        this.setLayoutX(x);
+        this.setLayoutY(y);
+    }
+
+    public void setWidth (double width) {
+        backgroundWidth = width;
+        background.setWidth(backgroundWidth);
+    }
+
+    private void update () {
+        background.setVisible(visibleAnnotations != 0);
+        background.setHeight(Math.abs(BACKGROUND_X) + TEXT_BUFFER + BACKGROUND_H_PER_TEXT * visibleAnnotations);
+        for (int i = 1; i <= visibleAnnotations; i++) {
+            Text text = (Text) this.getChildren().get(i);
+            if (text.visibleProperty().get())
+                text.relocate(X_OFFSET_TEXT, Y_OFFSET_TEXT_INIT * Y_OFFSET_PER_TEXT * (i + 1));
+        }
+    }
+
+    /**
+     * Return a text object with caching and a color applied
+     *
+     * @return The text object
+     */
+    private Text getTextObject() {
+        Text text = new Text();
+        text.setFill(theme);
+        text.setStrokeWidth(2);
+        text.setCacheHint(CacheHint.SPEED);
+        text.setCache(true);
+        return text;
+    }
+
+    public void setFill (Paint value) {
+        theme = value;
+        background.setStroke(theme);
+        annotationsByName.forEach((name, annotation) -> annotation.getText().setFill(theme));
+    }
+}

src/main/java/seng302/visualiser/fxObjects/BoatAnnotations.java

@@ -1,132 +0,0 @@
-package seng302.visualiser.fxObjects;
-
-import javafx.scene.CacheHint;
-import javafx.scene.Group;
-import javafx.scene.paint.Color;
-import javafx.scene.shape.Rectangle;
-import javafx.scene.text.Text;
-import seng302.model.Boat;
-import seng302.model.stream.parsers.StreamParser;
-
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
-
-/**
- * Collection of annotations for boats.
- */
-public class BoatAnnotations extends Group{
-
-    //Text offset constants
-    private static final double X_OFFSET_TEXT = 18d;
-    private static final double Y_OFFSET_TEXT_INIT = -29d;
-    private static final double Y_OFFSET_PER_TEXT = 12d;
-    //Background constants
-    private static final double TEXT_BUFFER = 3;
-    private static final double BACKGROUND_X = X_OFFSET_TEXT - TEXT_BUFFER;
-    private static final double BACKGROUND_Y = Y_OFFSET_TEXT_INIT - TEXT_BUFFER;
-    private static final double BACKGROUND_H_PER_TEXT = 9.5d;
-    private static final double BACKGROUND_W = 125d;
-    private static final double BACKGROUND_ARC_SIZE = 10;
-
-    private Rectangle background = new Rectangle();
-    private Text teamNameObject;
-    private Text velocityObject;
-    private Text estTimeToNextMarkObject;
-    private Text legTimeObject;
-
-    private Boat boat;
-
-    BoatAnnotations (Boat boat, Color theme) {
-        super.setCache(true);
-        this.boat = boat;
-        background.setX(BACKGROUND_X);
-        background.setY(BACKGROUND_Y);
-        background.setWidth(BACKGROUND_W);
-        background.setHeight(Math.abs(BACKGROUND_X) + TEXT_BUFFER + BACKGROUND_H_PER_TEXT * 4);
-        background.setArcHeight(BACKGROUND_ARC_SIZE);
-        background.setArcWidth(BACKGROUND_ARC_SIZE);
-        background.setFill(new Color(1, 1, 1, 0.75));
-        background.setStroke(theme);
-        background.setStrokeWidth(2);
-        background.setCache(true);
-        background.setCacheHint(CacheHint.SPEED);
-
-        teamNameObject = getTextObject(boat.getShortName(), theme);
-        teamNameObject.relocate(X_OFFSET_TEXT, Y_OFFSET_TEXT_INIT + Y_OFFSET_PER_TEXT);
-
-        velocityObject = getTextObject("0 m/s", theme);
-        velocityObject.relocate(X_OFFSET_TEXT, Y_OFFSET_TEXT_INIT + Y_OFFSET_PER_TEXT * 2);
-
-        estTimeToNextMarkObject = getTextObject("Next mark: ", theme);
-        estTimeToNextMarkObject.relocate(X_OFFSET_TEXT, Y_OFFSET_TEXT_INIT + Y_OFFSET_PER_TEXT * 3);
-
-        legTimeObject = getTextObject("Last mark: -", theme);
-        legTimeObject.relocate(X_OFFSET_TEXT, Y_OFFSET_TEXT_INIT + Y_OFFSET_PER_TEXT * 4);
-
-        super.getChildren().addAll(background, teamNameObject, velocityObject, estTimeToNextMarkObject, legTimeObject);
-    }
-
-    /**
-     * Return a text object with caching and a color applied
-     *
-     * @param defaultText The default text to display
-     * @param fill The text fill color
-     * @return The text object
-     */
-    private Text getTextObject(String defaultText, Color fill) {
-        Text text = new Text(defaultText);
-        text.setFill(fill);
-        text.setStrokeWidth(2);
-        text.setCacheHint(CacheHint.SPEED);
-        text.setCache(true);
-        return text;
-    }
-
-    void update () {
-        velocityObject.setText(String.format("%.2f m/s", boat.getVelocity()));
-
-        DateFormat format = new SimpleDateFormat("mm:ss");
-        if (boat.getTimeTillNext() != null) {
-            String timeToNextMark = format
-                    .format(boat.getTimeTillNext() - StreamParser.getCurrentTimeLong());
-            estTimeToNextMarkObject.setText("Next mark: " + timeToNextMark);
-        } else {
-            estTimeToNextMarkObject.setText("Next mark: -");
-        }
-
-        if (boat.getMarkRoundTime() != null) {
-            String elapsedTime = format
-                    .format(StreamParser.getCurrentTimeLong() - boat.getMarkRoundTime());
-            legTimeObject.setText("Last mark: " + elapsedTime);
-        }else {
-            legTimeObject.setText("Last mark: - ");
-        }
-    }
-
-    void setVisibile (boolean nameVisibility, boolean speedVisibility,
-                             boolean estTimeVisibility, boolean lastMarkVisibility) {
-        int totalVisible = 0;
-        totalVisible = updateVisibility(nameVisibility, teamNameObject, totalVisible);
-        totalVisible = updateVisibility(speedVisibility, velocityObject, totalVisible);
-        totalVisible = updateVisibility(estTimeVisibility, estTimeToNextMarkObject, totalVisible);
-        totalVisible = updateVisibility(lastMarkVisibility, legTimeObject, totalVisible);
-        if (totalVisible != 0) {
-            background.setVisible(true);
-            background.setHeight(Math.abs(BACKGROUND_X) + TEXT_BUFFER + BACKGROUND_H_PER_TEXT * totalVisible);
-        } else {
-            background.setVisible(false);
-        }
-    }
-
-    private int updateVisibility (boolean visibility, Text text, int totalVisible) {
-        if (visibility){
-            totalVisible ++;
-            text.setVisible(true);
-            text.setLayoutX(X_OFFSET_TEXT);
-            text.setLayoutY(Y_OFFSET_TEXT_INIT + Y_OFFSET_PER_TEXT * totalVisible);
-        } else {
-            text.setVisible(false);
-        }
-        return totalVisible;
-    }
-}

src/main/java/seng302/visualiser/fxObjects/BoatObject.java

@@ -6,10 +6,10 @@ import javafx.geometry.Point2D;
 import javafx.scene.CacheHint;
 import javafx.scene.Group;
 import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
 import javafx.scene.shape.Line;
 import javafx.scene.shape.Polygon;
 import javafx.scene.transform.Rotate;
-import seng302.visualiser.controllers.GameViewController;
 import seng302.model.Boat;
 import seng302.utilities.GeoUtility;
 import seng302.model.mark.GateMark;
@@ -25,7 +25,7 @@ import seng302.model.stream.parsers.StreamParser;
  * minimized in which case it attempts to store animations and apply them when the window is
  * maximised.
  */
-public class BoatGroup extends Group {
+public class BoatObject extends Group {
 
     //Constants for drawing
     private static final double BOAT_HEIGHT = 15d;
@@ -47,79 +47,57 @@ public class BoatGroup extends Group {
     private Double distanceTravelled = 0.0;
     private Point2D lastPoint;
     private boolean destinationSet;
-    private BoatAnnotations boatAnnotations;
+    private AnnotationBox annotationBox;
+
+    private Paint colour = Color.BLACK;
 
     private Boolean isSelected = true;  //All boats are initialised as selected
 
     /**
      * Creates a BoatGroup with the default triangular boat polygon.
-     *
-     * @param boat The boat that the BoatGroup will represent. Must contain an ID which will be used
-     * to tell which BoatGroup to update.
-     * @param color The colour of the boat polygon and the trailing line.
      */
-    public BoatGroup(Boat boat, Color color) {
-        destinationSet = false;
-        this.boat = boat;
-        initChildren(color);
+    public BoatObject() {
+        this(-BOAT_WIDTH / 2, BOAT_HEIGHT / 2,
+            0.0, -BOAT_HEIGHT / 2,
+            BOAT_WIDTH / 2, BOAT_HEIGHT / 2);
     }
 
     /**
      * Creates a BoatGroup with the boat being the default polygon. The head of the boat should be
      * at point (0,0).
      *
-     * @param boat The boat that the BoatGroup will represent. Must contain an ID which will be used
-     * to tell which BoatGroup to update.
-     * @param color The colour of the boat polygon and the trailing line.
      * @param points An array of co-ordinates x1,y1,x2,y2,x3,y3... that will make up the boat
      * polygon.
      */
-    public BoatGroup(Boat boat, Color color, double... points) {
-        destinationSet = false;
-        this.boat = boat;
-        initChildren(color, points);
-    }
-
-    /**
-     * Creates the javafx objects that will be the in the group by default.
-     *
-     * @param color The colour of the boat polygon and the trailing line.
-     * @param points An array of co-ordinates x1,y1,x2,y2,x3,y3... that will make up the boat
-     * polygon.
-     */
-    private void initChildren(Color color, double... points) {
+    public BoatObject(double... points) {
         boatPoly = new Polygon(points);
-        boatPoly.setFill(color);
+        boatPoly.setFill(colour);
         boatPoly.setOnMouseEntered(event -> {
             boatPoly.setFill(Color.FLORALWHITE);
             boatPoly.setStroke(Color.RED);
         });
         boatPoly.setOnMouseExited(event -> {
-            boatPoly.setFill(color);
+            boatPoly.setFill(colour);
             boatPoly.setStroke(Color.BLACK);
         });
         boatPoly.setOnMouseClicked(event -> setIsSelected(!isSelected));
         boatPoly.setCache(true);
         boatPoly.setCacheHint(CacheHint.SPEED);
-        boatAnnotations = new BoatAnnotations(boat, color);
+
+        annotationBox = new AnnotationBox();
+        annotationBox.setFill(colour);
 
         leftLayLine = new Line();
         rightLayline = new Line();
 
         wake = new Wake(0, -BOAT_HEIGHT);
-        super.getChildren().addAll(boatPoly, boatAnnotations);
+        super.getChildren().addAll(boatPoly, annotationBox);
     }
 
-    /**
-     * Creates the javafx objects that will be the in the group by default.
-     *
-     * @param color The colour of the boat polygon and the trailing line.
-     */
-    private void initChildren(Color color) {
-        initChildren(color,
-            -BOAT_WIDTH / 2, BOAT_HEIGHT / 2,
-            0.0, -BOAT_HEIGHT / 2,
-            BOAT_WIDTH / 2, BOAT_HEIGHT / 2);
+    public void setFill (Paint value) {
+        this.colour = value;
+        boatPoly.setFill(colour);
+        annotationBox.setFill(colour);
     }
 
     /**
@@ -132,8 +110,8 @@ public class BoatGroup extends Group {
     private void moveGroupBy(double dx, double dy) {
         boatPoly.setLayoutX(boatPoly.getLayoutX() + dx);
         boatPoly.setLayoutY(boatPoly.getLayoutY() + dy);
-        boatAnnotations.setLayoutX(boatAnnotations.getLayoutX() + dx);
-        boatAnnotations.setLayoutY(boatAnnotations.getLayoutY() + dy);
+        annotationBox.setLayoutX(annotationBox.getLayoutX() + dx);
+        annotationBox.setLayoutY(annotationBox.getLayoutY() + dy);
         wake.setLayoutX(wake.getLayoutX() + dx);
         wake.setLayoutY(wake.getLayoutY() + dy);
     }
@@ -149,8 +127,8 @@ public class BoatGroup extends Group {
         rotateTo(rotation);
         boatPoly.setLayoutX(x);
         boatPoly.setLayoutY(y);
-        boatAnnotations.setLayoutX(x);
-        boatAnnotations.setLayoutY(y);
+        annotationBox.setLayoutX(x);
+        annotationBox.setLayoutY(y);
         wake.setLayoutX(x);
         wake.setLayoutY(y);
         wake.rotate(rotation);
@@ -225,54 +203,52 @@ public class BoatGroup extends Group {
         lastTimeValid = timeValid;
         isStopped = false;
         lastRotation = rotation;
-        boatAnnotations.update();
     }
 
 
-    /**
-     * This function works out if a boat is going upwind or down wind. It looks at the boats current position, the next
-     * gates position and the current wind
-     * If bot the wind vector from the next gate and the boat from the next gate lay on the same side, then the boat is
-     * going up wind, if they are on different sides of the gate, then the boat is going downwind
-     * @param canvasController
-     */
-    public Boolean isUpwindLeg(GameViewController canvasController, Mark nextMark) {
-
-        Double windAngle = StreamParser.getWindDirection();
-        GateMark thisGateMark = (GateMark) nextMark;
-        SingleMark nextMark1 = thisGateMark.getSingleMark1();
-        SingleMark nextMark2 = thisGateMark.getSingleMark2();
-        Point2D nextMarkPoint1 = canvasController.findScaledXY(nextMark1.getLatitude(), nextMark1.getLongitude());
-        Point2D nextMarkPoint2 = canvasController.findScaledXY(nextMark2.getLatitude(), nextMark2.getLongitude());
-
-        Point2D boatCurrentPoint = new Point2D(boatPoly.getLayoutX(), boatPoly.getLayoutY());
-        Point2D windTestPoint = GeoUtility.makeArbitraryVectorPoint(nextMarkPoint1, windAngle, 10d);
-
-
-        Integer boatLineFuncResult = GeoUtility.lineFunction(nextMarkPoint1, nextMarkPoint2, boatCurrentPoint);
-        Integer windLineFuncResult = GeoUtility.lineFunction(nextMarkPoint1, nextMarkPoint2, windTestPoint);
-
-
-        /*
-        If both the wind vector from the gate and the boat from the gate are on the same side of that gate, then the
-        boat is travelling into the wind. thus upwind. Otherwise if they are on different sides, then the boat is going
-        with the wind.
-         */
-        return boatLineFuncResult.equals(windLineFuncResult);
-    }
+//    /**
+//     * This function works out if a boat is going upwind or down wind. It looks at the boats current position, the next
+//     * gates position and the current wind
+//     * If bot the wind vector from the next gate and the boat from the next gate lay on the same side, then the boat is
+//     * going up wind, if they are on different sides of the gate, then the boat is going downwind
+//     * @param canvasController
+//     */
+//    public Boolean isUpwindLeg(GameViewController canvasController, Mark nextMark) {
+//
+//        Double windAngle = StreamParser.getWindDirection();
+//        GateMark thisGateMark = (GateMark) nextMark;
+//        SingleMark nextMark1 = thisGateMark.getSingleMark1();
+//        SingleMark nextMark2 = thisGateMark.getSingleMark2();
+//        Point2D nextMarkPoint1 = canvasController.findScaledXY(nextMark1.getLatitude(), nextMark1.getLongitude());
+//        Point2D nextMarkPoint2 = canvasController.findScaledXY(nextMark2.getLatitude(), nextMark2.getLongitude());
+//
+//        Point2D boatCurrentPoint = new Point2D(boatPoly.getLayoutX(), boatPoly.getLayoutY());
+//        Point2D windTestPoint = GeoUtility.makeArbitraryVectorPoint(nextMarkPoint1, windAngle, 10d);
+//
+//
+//        Integer boatLineFuncResult = GeoUtility.lineFunction(nextMarkPoint1, nextMarkPoint2, boatCurrentPoint);
+//        Integer windLineFuncResult = GeoUtility.lineFunction(nextMarkPoint1, nextMarkPoint2, windTestPoint);
+//
+//
+//        /*
+//        If both the wind vector from the gate and the boat from the gate are on the same side of that gate, then the
+//        boat is travelling into the wind. thus upwind. Otherwise if they are on different sides, then the boat is going
+//        with the wind.
+//         */
+//        return boatLineFuncResult.equals(windLineFuncResult);
+//        return true;
+//    }
 
     public void setIsSelected(Boolean isSelected) {
         this.isSelected = isSelected;
         setLineGroupVisible(isSelected);
         setWakeVisible(isSelected);
-        boatAnnotations.setVisible(isSelected);
+        annotationBox.setVisible(isSelected);
         setLayLinesVisible(isSelected);
     }
 
     public void setVisibility (boolean teamName, boolean velocity, boolean estTime, boolean legTime,
         boolean trail, boolean wake) {
-
-        boatAnnotations.setVisibile(teamName, velocity, estTime, legTime);
         this.wake.setVisible(wake);
         this.lineGroup.setVisible(trail);
     }
@@ -324,7 +300,7 @@ public class BoatGroup extends Group {
     }
 
     public Group getAnnotations() {
-        return boatAnnotations;
+        return annotationBox;
     }
 
     public Double getBoatLayoutX() {

src/main/java/seng302/visualiser/fxObjects/MarkObject.java

@@ -16,7 +16,7 @@ import seng302.model.mark.SingleMark;
 /**
  * Grouping of javaFX objects needed to represent a Mark on screen.
  */
-public class MarkGroup extends Group {
+public class MarkObject extends Group {
 
     private static int MARK_RADIUS        = 5;
     private static int LINE_THICKNESS     = 2;
@@ -31,7 +31,7 @@ public class MarkGroup extends Group {
      * @param mark
      * @param points
      */
-    public MarkGroup (SingleMark mark, Point2D points) {
+    public MarkObject(SingleMark mark, Point2D points) {
         marks.add(mark);
         mainMark = mark;
         Color color = Color.BLACK;
@@ -73,7 +73,7 @@ public class MarkGroup extends Group {
         super.getChildren().removeAll(toRemove);
     }
 
-    public MarkGroup(GateMark mark, Point2D points1, Point2D points2) {
+    public MarkObject(GateMark mark, Point2D points1, Point2D points2) {
         marks.add(mark.getSingleMark1());
         marks.add(mark.getSingleMark2());
         mainMark = mark;