refresh feature in progress

src/main/java/jfxtras/labs/map/MapPane.java

@@ -48,7 +48,7 @@
 import javafx.scene.text.FontSmoothingType;
 import javafx.scene.text.Text;
 import jfxtras.labs.map.render.TileRenderer;
-import jfxtras.labs.map.tile.TilesProvideable;
+import jfxtras.labs.map.tile.TileProvideable;
 import jfxtras.labs.map.tile.TileRepository;
 import static javafx.collections.FXCollections.*;
 import static jfxtras.labs.map.CoordinatesConverter.*;
@@ -69,7 +69,7 @@ public final class MapPane extends Pane implements MapTilesourceable {
 
 	private static final String STYLE_LOC = "cursorLocation";
 
-	private TilesProvideable tilesProvider;
+	private TileProvideable tilesProvider;
 
 	private TileRenderable tileRenderer;
 
@@ -379,7 +379,6 @@ public void moveMap(int x, int y) {
 		center.x += x;
 		center.y += y;
 
-		//TODO check on edge
 		if(prepareTiles() > 0 && !isOnEdge()){
 			tilesPrepared = true;
 		}else{

src/main/java/jfxtras/labs/map/MapTilesourceable.java

@@ -1,6 +1,5 @@
 package jfxtras.labs.map;
 
-import javafx.scene.Group;
 import jfxtras.labs.map.tile.TileSource;
 
 /**
@@ -10,8 +9,6 @@
  */
 public interface MapTilesourceable extends CursorLocationable{
 
-	Group getTilesGroup();
-
     TileSource getTileSource();
 
 }

src/main/java/jfxtras/labs/map/Moveable.java

@@ -2,6 +2,8 @@
 
 import java.awt.Point;
 
+import javafx.scene.Group;
+
 /**
  * This interface defines methods to move the map.
  *
@@ -43,4 +45,6 @@ public interface Moveable extends Zoomable{
      */
     void centerMap();
 
+	Group getTilesGroup();
+
 }

src/main/java/jfxtras/labs/map/TilesMouseHandler.java

@@ -148,7 +148,7 @@ private class MouseReleasedAdapter implements EventHandler<MouseEvent> {
 		@Override
 		public void handle(MouseEvent me) {
 			tilesGroup.setCursor(Cursor.CROSSHAIR);
-			if (isMoveable()) {
+			if(isMoveable()){
 				moveMap(me);
 				dragStartPoint = null;
 			}

src/main/java/jfxtras/labs/map/render/TileRenderable.java

@@ -37,6 +37,12 @@ public interface TileRenderable {
 	 */
 	void render(Group tilesGroup);
 
+	/**
+	 * Reloads all tile which currently visible.
+	 * @param mapController
+	 */
+	void refresh(Moveable mapController);
+
 	/**
 	 * Turn monochrome mode on/off.
 	 * @param val

src/main/java/jfxtras/labs/map/render/TileRenderer.java

@@ -14,12 +14,14 @@
 import javafx.scene.shape.MoveTo;
 import javafx.scene.shape.Path;
 import jfxtras.labs.map.Moveable;
-import jfxtras.labs.map.tile.DefaultTilesLoader;
-import jfxtras.labs.map.tile.TilesProvideable;
+import jfxtras.labs.map.tile.CacheLoadStrategy;
+import jfxtras.labs.map.tile.RefreshLoadStrategy;
+import jfxtras.labs.map.tile.TileProvideable;
 import jfxtras.labs.map.tile.TileImageComparator;
 import jfxtras.labs.map.tile.TileImage;
 import jfxtras.labs.map.tile.TilesLoadable;
 import jfxtras.labs.map.tile.TileSource;
+import jfxtras.labs.map.tile.TilesLoader;
 
 /**
  * Rendered for map tiles.
@@ -41,21 +43,32 @@ public class TileRenderer implements TileRenderable {
 
 	private List<TileImage> tileImages;
 
-	private final TilesProvideable tileCache;
+	private final TileProvideable provider;
 
 
-	public TileRenderer(TilesProvideable tileCache) {
-		this.tileCache = tileCache;
+	public TileRenderer(TileProvideable provider) {
+		this.provider = provider;
 		this.tileImages = emptyList();
 	}
 
 	@Override
 	public int prepareTiles(Moveable mapController) {
-
-		tileImages = loadTiles(mapController);
+		provider.setStrategy(new CacheLoadStrategy());
+		TilesLoadable tileLoader = new TilesLoader(provider);
+		tileImages = tileLoader.loadTiles(mapController);
 		return tileImages.size();
 	}
-
+
+	@Override
+	public void refresh(Moveable mapController) {
+		provider.setStrategy(new RefreshLoadStrategy());
+		TilesLoadable tileLoader = new TilesLoader(provider);
+		tileImages = tileLoader.loadTiles(mapController);
+		if(tileImages.isEmpty()){
+			render(mapController.getTilesGroup());
+		}
+	}
+
 	@Override
 	public Point[] getBounds() {
 		Point[] bounds = new Point[0];
@@ -72,21 +85,11 @@ public Point[] getBounds() {
 		return bounds;
 	}
 
-	/**
-	 * Load the tiles in a spiral, starting from center of the map.
-	 */
-	private List<TileImage> loadTiles(Moveable mapController) {
-
-		TilesLoadable tileLoader = new DefaultTilesLoader(tileCache);
-		return tileLoader.loadTiles(mapController);
-	}
-
 	private int getTileSize() {
-		TileSource tileSource = tileCache.getTileSource();
+		TileSource tileSource = provider.getTileSource();
 		return tileSource.getTileSize();
 	}
 
-
 	@Override
 	public void render(Group tilesGroup) {
 
@@ -109,7 +112,7 @@ public void render(Group tilesGroup) {
 			}
 
 			if (tileGridVisible) {
-				tilesGroup.getChildren().add(createGrid(posx, posy, tilesize));
+				tilesGroup.getChildren().add(createBorder(posx, posy, tilesize));
 			}
 		}
 	}
@@ -123,7 +126,7 @@ private void setMonochromeEffect(ImageView imageView) {
 		imageView.setEffect(monochrome);
 	}
 
-	protected Path createGrid(int posx, int posy, int tilesize) {
+	protected Path createBorder(int posx, int posy, int tilesize) {
 
 		Path path = new Path();
 		path.getElements().add(new MoveTo(posx, posy));

src/main/java/jfxtras/labs/map/tile/AbstractTileLoadStrategy.java

@@ -0,0 +1,75 @@
+package jfxtras.labs.map.tile;
+
+import java.util.Objects;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.scene.image.Image;
+
+/**
+ * Abstract parent class for tile load commands.
+ * @author Mario Schroeder
+ *
+ */
+public abstract class AbstractTileLoadStrategy implements TileLoadStrategy{
+	protected TileInfoCache cache;
+
+	public void setCache(TileInfoCache cache){
+		this.cache = cache;
+	}
+
+	Tile createTile(String location) {
+		Tile tile = new Tile(location);
+		loadImage(tile);
+		return tile;
+	}
+
+	private void loadImage(Tile tile) {
+		ChangeListener<Boolean> listener = new ImageLoadedListener(tile);
+		tile.imageLoadedProperty().addListener(listener);
+		tile.loadImage();
+	}
+
+	@Override
+	public String toString() {
+		return getClass().getSimpleName();
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		boolean equal = false;
+		if(obj != null && getClass() == obj.getClass()){
+			equal = Objects.equals(this.toString(), obj.toString());
+		}
+		return equal;
+	}
+
+	@Override
+	public int hashCode() {
+		return toString().hashCode();
+	}
+
+	private class ImageLoadedListener implements ChangeListener<Boolean> {
+
+        private Tile tile;
+
+        public ImageLoadedListener(Tile tile) {
+            this.tile = tile;
+        }
+
+        @Override
+        public void changed(
+            ObservableValue<? extends Boolean> ov, Boolean oldVal, Boolean newVal) {
+            if (newVal.booleanValue()) {
+                addImage(tile.getLocation(), tile.getImageView().getImage());
+            }
+        }
+
+        private void addImage(String tileLocation, Image image) {
+
+            long timeStamp = System.currentTimeMillis();
+            TileInfo info = new TileInfo(timeStamp, image);
+            cache.put(tileLocation, info);
+        }
+    }
+}

src/main/java/jfxtras/labs/map/tile/CacheLoadStrategy.java

@@ -0,0 +1,25 @@
+package jfxtras.labs.map.tile;
+
+/**
+ * This class checks the {@link TileInfoCache} first if the 
+ * {@link Tile} exists and loads it from there.
+ * 
+ * @author Mario Schroeder
+ *
+ */
+public class CacheLoadStrategy extends AbstractTileLoadStrategy {
+
+	@Override
+	public Tile execute(String location) {
+		Tile tile;
+		TileInfo info = cache.get(location);
+
+        if (info != null) {
+            tile = new Tile(location, info.getImage());
+        } else {
+            tile = createTile(location);
+        }
+        return tile;
+	}
+
+}

src/main/java/jfxtras/labs/map/tile/RefreshLoadStrategy.java

@@ -0,0 +1,22 @@
+package jfxtras.labs.map.tile;
+
+/**
+ * This class reloads the {@link Tile} in the {@link TileInfoCache}.
+ * 
+ * @author Mario Schroeder
+ *
+ */
+public class RefreshLoadStrategy extends AbstractTileLoadStrategy {
+
+	@Override
+	public Tile execute(String location) {
+		TileInfo info = cache.get(location);
+
+        if (info != null) {
+        	cache.remove(location);
+        } 
+
+        return createTile(location); 
+	}
+
+}

src/main/java/jfxtras/labs/map/tile/TileLoadStrategy.java

@@ -0,0 +1,13 @@
+package jfxtras.labs.map.tile;
+
+/**
+ * Interface for way to load the tiles.
+ * @author Mario Schroeder
+ *
+ */
+public interface TileLoadStrategy {
+
+	Tile execute(String location);
+
+	void setCache(TileInfoCache cache);
+}

src/main/java/jfxtras/labs/map/tile/TileProvideable.java

@@ -0,0 +1,24 @@
+package jfxtras.labs.map.tile;
+
+/**
+ * This interface defines methods to load the tile. 
+ * The loading algorithm can be influenced with the {@link TileLoadStrategy}.
+ * @author Mario Schroeder
+ *
+ */
+public interface TileProvideable extends TilesSourceAccessable{
+
+	/**
+	 * Returns the tile for x, y and zoom. 
+	 * It might also return null if the arguments are invalid.
+	 * @param tilex x position of the tile
+	 * @param tiley y position of the tile
+	 * @param zoom the zoom level
+	 * @return the {@link Tile} or null if arguments are invalid.
+	 */
+	Tile getTile(int tilex, int tiley, int zoom);
+
+	void setStrategy(TileLoadStrategy strategy);
+
+	TileLoadStrategy getStrategy();
+}