make VectorTileLayer extendable

vtm/src/org/oscim/layers/tile/BitmapTileLayer.java

@@ -30,8 +30,8 @@ import org.oscim.renderer.elements.BitmapLayer;
 import org.oscim.renderer.elements.ElementLayers;
 import org.oscim.tiling.ITileDataSink;
 import org.oscim.tiling.ITileDataSource;
-import org.oscim.tiling.TileSource;
 import org.oscim.tiling.ITileDataSource.QueryResult;
+import org.oscim.tiling.TileSource;
 import org.oscim.utils.FastMath;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -61,9 +61,14 @@ public class BitmapTileLayer extends TileLayer {
 	}
 
 	public BitmapTileLayer(Map map, TileSource tileSource, int cacheLimit) {
-		super(map, tileSource.getZoomLevelMin(), tileSource.getZoomLevelMax(), cacheLimit);
+		super(map,
+		      new TileManager(map,
+		                      tileSource.getZoomLevelMin(),
+		                      tileSource.getZoomLevelMax(),
+		                      cacheLimit),
+		      new VectorTileRenderer());
+
 		mTileSource = tileSource;
-		setRenderer(new VectorTileRenderer(mTileManager));
 		initLoader(4);
 	}
 

vtm/src/org/oscim/layers/tile/MapTile.java

@@ -66,8 +66,8 @@ public class MapTile extends Tile {
 		public final static byte CANCEL = 1 << 3;
 	}
 
-	public MapTile(TileNode node, int tileX, int tileY, byte zoomLevel) {
+	public MapTile(TileNode node, int tileX, int tileY, int zoomLevel) {
-		super(tileX, tileY, zoomLevel);
+		super(tileX, tileY, (byte)zoomLevel);
 		this.x = (double) tileX / (1 << zoomLevel);
 		this.y = (double) tileY / (1 << zoomLevel);
 		this.node = node;

vtm/src/org/oscim/layers/tile/TileLayer.java

@@ -28,31 +28,25 @@ public abstract class TileLayer extends Layer implements UpdateListener {
 
 	static final Logger log = LoggerFactory.getLogger(TileLayer.class);
 
-	private final static int MAX_ZOOMLEVEL = 17;
+	/**
-	private final static int MIN_ZOOMLEVEL = 2;
+	 * TileManager responsible for adding visible tiles
-	private final static int CACHE_LIMIT = 150;
+	 * to load queue and managing in-memory tile cache.
-
+	 */
 	protected final TileManager mTileManager;
 
 	protected TileLoader[] mTileLoader;
 
-	public TileLayer(Map map) {
+	public TileLayer(Map map, TileManager tileManager, TileRenderer renderer) {
-		this(map, MIN_ZOOMLEVEL, MAX_ZOOMLEVEL, CACHE_LIMIT);
-	}
-
-	public TileLayer(Map map, int minZoom, int maxZoom, int cacheLimit) {
 		super(map);
-		/* TileManager responsible for adding visible tiles
+		renderer.setTileManager(tileManager);
-		 * to load queue and managing in-memory tile cache. */
+
-		mTileManager = new TileManager(map, minZoom, maxZoom, cacheLimit);
+		mTileManager = tileManager;
+		mRenderer = renderer;
+
 	}
 
 	abstract protected TileLoader createLoader(TileManager tm);
 
-	protected void setRenderer(TileRenderer renderer) {
-		mRenderer = renderer;
-	}
-
 	public TileRenderer tileRenderer() {
 		return (TileRenderer) mRenderer;
 	}

vtm/src/org/oscim/layers/tile/TileManager.java

@@ -107,14 +107,6 @@ public class TileManager {
 
 	private final QuadTree<TileNode, MapTile> mIndex = new QuadTree<TileNode, MapTile>() {
 
-		@Override
-		public MapTile create(int x, int y, int z) {
-			TileNode t = super.add(x, y, z);
-			t.item = new MapTile(t, x, y, (byte) z);
-
-			return t.item;
-		}
-
 		@Override
 		public void removeItem(MapTile t) {
 			if (t.node == null) {
@@ -204,9 +196,6 @@ public class TileManager {
 		 * jobs come in. */
 		jobQueue.clear();
 
-		// load some tiles more than currently visible (* 0.75)
-		//double scale = pos.scale * 0.9f;
-
 		int tileZoom = FastMath.clamp(pos.zoomLevel, mMinZoom, mMaxZoom);
 
 		if (mZoomTable != null) {
@@ -352,7 +341,8 @@ public class TileManager {
 		MapTile tile = mIndex.getTile(x, y, zoomLevel);
 
 		if (tile == null) {
-			tile = mIndex.create(x, y, zoomLevel);
+			TileNode n = mIndex.add(x, y, zoomLevel);
+			tile = n.item = new MapTile(n, x, y, zoomLevel);
 			mJobs.add(tile);
 			addToCache(tile);
 		} else if (!tile.isActive()) {
@@ -363,7 +353,8 @@ public class TileManager {
 			/* prefetch parent */
 			MapTile p = tile.node.parent.item;
 			if (p == null) {
-				p = mIndex.create(x >> 1, y >> 1, zoomLevel - 1);
+				TileNode n = mIndex.add(x >> 1, y >> 1, zoomLevel - 1);
+				p = n.item = new MapTile(n, x >> 1, y >> 1, zoomLevel - 1);
 				addToCache(p);
 				// hack to not add tile twice to queue
 				p.state = LOADING;

vtm/src/org/oscim/layers/tile/TileRenderer.java

@@ -36,7 +36,7 @@ public abstract class TileRenderer extends LayerRenderer {
 	/** fade-in time */
 	protected static final float FADE_TIME = 500;
 
-	private final TileManager mTileManager;
+	private TileManager mTileManager;
 
 	protected final TileSet mDrawTiles;
 	protected int mProxyTileCnt;
@@ -49,12 +49,15 @@ public abstract class TileRenderer extends LayerRenderer {
 
 	private int mUploadSerial;
 
-	public TileRenderer(TileManager tileManager) {
+	public TileRenderer() {
-		mTileManager = tileManager;
 		mUploadSerial = 0;
 		mDrawTiles = new TileSet();
 	}
 
+	protected void setTileManager(TileManager tileManager) {
+		mTileManager = tileManager;
+	}
+
 	/**
 	 * Current number of frames drawn, used to not draw a
 	 * tile twice per frame.

vtm/src/org/oscim/layers/tile/VectorTileRenderer.java

@@ -31,9 +31,9 @@ public class VectorTileRenderer extends TileRenderer {
 
 	protected GLMatrix mViewProj = new GLMatrix();
 
-	public VectorTileRenderer(TileManager tileManager) {
+	//	public VectorTileRenderer(TileManager tileManager) {
-		super(tileManager);
+	//		super(tileManager);
-	}
+	//	}
 
 	@Override
 	protected synchronized void update(GLViewport v) {

vtm/src/org/oscim/layers/tile/example/TestTileLayer.java

@@ -24,6 +24,7 @@ import org.oscim.layers.tile.MapTile;
 import org.oscim.layers.tile.TileLayer;
 import org.oscim.layers.tile.TileLoader;
 import org.oscim.layers.tile.TileManager;
+import org.oscim.layers.tile.VectorTileRenderer;
 import org.oscim.map.Map;
 import org.oscim.renderer.elements.ElementLayers;
 import org.oscim.renderer.elements.LineLayer;
@@ -35,7 +36,9 @@ public class TestTileLayer extends TileLayer {
 	static final Logger log = LoggerFactory.getLogger(TestTileLayer.class);
 
 	public TestTileLayer(Map map) {
-		super(map);
+		super(map,
+		      new TileManager(map, 0, 20, 10),
+		      new VectorTileRenderer());
 	}
 
 	@Override

vtm/src/org/oscim/layers/tile/vector/VectorTileLayer.java

@@ -35,17 +35,20 @@ import org.slf4j.LoggerFactory;
 public class VectorTileLayer extends TileLayer {
 	static final Logger log = LoggerFactory.getLogger(VectorTileLayer.class);
 
-	private TileSource mTileSource;
+	protected final static int MAX_ZOOMLEVEL = 17;
+	protected final static int MIN_ZOOMLEVEL = 2;
+	protected final static int CACHE_LIMIT = 150;
+
+	protected TileSource mTileSource;
 
 	public VectorTileLayer(Map map) {
-		super(map);
+		this(map, MIN_ZOOMLEVEL, MAX_ZOOMLEVEL, CACHE_LIMIT);
-		setRenderer(new VectorTileRenderer(mTileManager));
-		initLoader(4);
 	}
 
 	public VectorTileLayer(Map map, int minZoom, int maxZoom, int cacheLimit) {
-		super(map, minZoom, maxZoom, cacheLimit);
+		super(map, new TileManager(map, minZoom, maxZoom, cacheLimit),
-		setRenderer(new VectorTileRenderer(mTileManager));
+		      new VectorTileRenderer());
+
 		initLoader(4);
 	}
 

vtm/src/org/oscim/utils/quadtree/BoxTree.java

@@ -96,15 +96,9 @@ public abstract class BoxTree<Box extends BoxItem<E>, E> extends QuadTree<BoxNod
 		this.maxDepth = maxDepth;
 	}
 
-	@Override
-	public Box create(int x, int y, int z) {
-		return null;
-	}
-
 	@Override
 	public BoxNode<Box> create() {
-		BoxNode<Box> node = new BoxNode<Box>();
+		return new BoxNode<Box>();
-		return node;
 	}
 
 	@Override

vtm/src/org/oscim/utils/quadtree/QuadTree.java

@@ -39,8 +39,6 @@ public abstract class QuadTree<T extends Node<T, E>, E> {
 		}
 	}
 
-	public abstract E create(int x, int y, int z);
-
 	public abstract T create();
 
 	public abstract void removeItem(E item);