TileGrid.java
/*
* *************************************************************************************************************************************************************
*
* MapView: a JavaFX map renderer for tile-based servers
* http://tidalwave.it/projects/mapview
*
* Copyright (C) 2024 - 2025 by Tidalwave s.a.s. (http://tidalwave.it)
*
* *************************************************************************************************************************************************************
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
*
* *************************************************************************************************************************************************************
*
* git clone https://bitbucket.org/tidalwave/mapview-src
* git clone https://github.com/tidalwave-it/mapview-src
*
* *************************************************************************************************************************************************************
*/
package it.tidalwave.mapviewer.javafx.impl;
import jakarta.annotation.Nonnull;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;
import java.net.URI;
import javafx.beans.property.ObjectProperty;
import javafx.scene.Node;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.StackPane;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import it.tidalwave.mapviewer.MapCoordinates;
import it.tidalwave.mapviewer.TileSource;
import it.tidalwave.mapviewer.impl.MapViewModel;
import it.tidalwave.mapviewer.javafx.MapView;
import lombok.experimental.Accessors;
import lombok.extern.slf4j.Slf4j;
import static java.lang.Double.doubleToLongBits;
/***************************************************************************************************************************************************************
*
* A grid of tiles, used to completely fill an arbitrary area of a graphic device.
*
* @author Fabrizio Giudici
*
**************************************************************************************************************************************************************/
@Slf4j @Accessors(fluent = true)
public class TileGrid extends StackPane
{
enum Dirty
{
/** Not dirty */ NONE,
/** Only grid needs to be rebuilt. */ GRID,
/** All need to be rebuilt, */ ALL
}
/** The owner component. */
@Nonnull @SuppressFBWarnings("EI_EXPOSE_REP2")
private final MapView parent;
/** The tile source. */
@Nonnull
private final ObjectProperty<TileSource> tileSource;
/** The model. */
@Nonnull
private final MapViewModel model;
/** The tile cache. */
@Nonnull
private final TileCache tileCache;
/** Whether this control needs to be redrawn. */
private Dirty dirty = Dirty.NONE;
/** The map of overlays indexed by name. */
private final Map<String, MapOverlay> overlayByName = new HashMap<>();
/** The container of tiles. */
private final GridPane tilePane = new GridPane();
/** The container of overlays. */
private final StackPane overlayPane = new StackPane();
/***********************************************************************************************************************************************************
* Creates a grid of tiles.
* @param parent the map view control
* @param model the map model
* @param tileSource the tile source
* @param tileCache the tile cache
**********************************************************************************************************************************************************/
@SuppressFBWarnings({"EI_EXPOSE_REP2", "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR"})
public TileGrid (@Nonnull final MapView parent,
@Nonnull final MapViewModel model,
@Nonnull final ObjectProperty<TileSource> tileSource,
@Nonnull final TileCache tileCache)
{
this.parent = parent;
this.tileSource = tileSource;
this.model = model;
this.tileCache = tileCache;
getChildren().addAll(tilePane, overlayPane);
parent.layoutBoundsProperty().addListener((_1, _2, _3) -> setDirty(Dirty.GRID));
model.setCenterAndZoom(MapCoordinates.of(0, 0), 1);
tileSource.addListener((_1, _2, _3) -> onTileSourceChanged());
}
/***********************************************************************************************************************************************************
* Sets the coordinates at the center of the grid and the zoom level. This method will update the tiles in the grid with the proper URLs for the required
* setting. If the grid is already populated, existing tiles are recycled if possible (this is useful while moving the coordinates in order to avoid the
* number of tiles to download for the next position).
* @param center the center at the center of the tile
* @param zoom the zoom level
**********************************************************************************************************************************************************/
public void setCenterAndZoom (@Nonnull final MapCoordinates center, final double zoom)
{
log.debug("setCenterAndZoom({}, {})", center, zoom);
if (!center.equals(model.center()) || doubleToLongBits(zoom) != doubleToLongBits(model.zoom())) // defensive
{
model.setCenterAndZoom(center, zoom);
createTiles();
recreateOverlays();
setDirty(Dirty.ALL);
}
}
/***********************************************************************************************************************************************************
* {@return the coordinates of the point at the center of the map}.
**********************************************************************************************************************************************************/
@Nonnull
public MapCoordinates getCenter()
{
return model.center();
}
/***********************************************************************************************************************************************************
* Translates the tile grid. If the translation is so large that the tile at the center changes, the grid is recomputed and translated back.
* @param deltaX the drag in screen coordinates
* @param deltaY the drag in screen coordinates
**********************************************************************************************************************************************************/
public void translate (final double deltaX, final double deltaY)
{
log.trace("translate({}, {})", deltaX, deltaY);
final var prevTileCenter = model.tileCenter();
model.setCenterAndZoom(model.pointCenter().translated(-deltaX, -deltaY), model.zoom());
final var tileCenter = model.tileCenter();
if (!prevTileCenter.equals(tileCenter))
{
createTiles();
// no need to recreate overlays, just translate them
final var dX = overlayPane.getTranslateX() -(tileCenter.column - prevTileCenter.column) * tileSource.get().getTileSize();
final var dY = overlayPane.getTranslateY() -(tileCenter.row - prevTileCenter.row) * tileSource.get().getTileSize();
log.debug("translate overlays: {}, {}", dX, dY);
overlayPane.setTranslateX(dX);
overlayPane.setTranslateY(dY);
setDirty(Dirty.GRID);
}
else
{
applyTranslate();
}
}
/***********************************************************************************************************************************************************
* Adds an overlay.
* @param name the name of the overlay
* @param creator the overlay creator
**********************************************************************************************************************************************************/
public void addOverlay (@Nonnull final String name, @Nonnull final Consumer<MapView.OverlayHelper> creator)
{
final var overlay = new MapOverlay(model, creator);
overlayPane.getChildren().add(overlay);
overlayByName.put(name, overlay);
overlay.create();
}
/***********************************************************************************************************************************************************
* Removes an overlay.
* @param name the name of the overlay to remove
**********************************************************************************************************************************************************/
public void removeOverlay (@Nonnull final String name)
{
if (overlayByName.containsKey(name))
{
overlayPane.getChildren().remove(overlayByName.remove(name));
}
}
/***********************************************************************************************************************************************************
* Removes all overlays.
**********************************************************************************************************************************************************/
public void removeAllOverlays()
{
overlayByName.clear();
overlayPane.getChildren().clear();
}
/***********************************************************************************************************************************************************
* {@inheritDoc}
**********************************************************************************************************************************************************/
@Override
protected void layoutChildren()
{
log.trace("layoutChildren");
if (dirty != Dirty.NONE && isVisible())
{
final var parentWidth = parent.getWidth();
final var parentHeight = parent.getHeight();
final var centerTileChanged = model.updateGridSize(parentWidth, parentHeight);
model.recompute();
if (centerTileChanged)
{
log.debug("new view size: {} x {}, new grid size: {} x {}", parentWidth, parentHeight, model.columns(), model.rows());
createTiles();
if (dirty == Dirty.ALL)
{
recreateOverlays();
}
}
else
{
applyTranslate();
}
}
dirty = Dirty.NONE;
super.layoutChildren();
}
/***********************************************************************************************************************************************************
*
**********************************************************************************************************************************************************/
private void onTileSourceChanged()
{
log.debug("onTileSourceChanged()");
model.setTileSource(tileSource.get());
createTiles();
setDirty(Dirty.GRID);
}
/***********************************************************************************************************************************************************
*
**********************************************************************************************************************************************************/
private void createTiles()
{
log.debug("createTiles()");
tilePane.getChildren().clear();
model.iterateOnGrid((pos, url) -> tilePane.add(createTile(url), pos.column(), pos.row(), 1, 1));
applyTranslate();
}
/***********************************************************************************************************************************************************
*
**********************************************************************************************************************************************************/
private void recreateOverlays()
{
log.debug("recreateOverlays()");
overlayPane.setTranslateX(0);
overlayPane.setTranslateY(0);
overlayByName.values().forEach(MapOverlay::create);
}
/***********************************************************************************************************************************************************
*
**********************************************************************************************************************************************************/
@Nonnull
private Node createTile (@Nonnull final URI uri)
{
return new Tile(tileCache, tileSource.get(), uri, tileSource.get().getTileSize(), (int)model.zoom());
}
/***********************************************************************************************************************************************************
*
**********************************************************************************************************************************************************/
private void applyTranslate()
{
setTranslateX(model.gridOffset().x());
setTranslateY(model.gridOffset().y());
}
/***********************************************************************************************************************************************************
*
**********************************************************************************************************************************************************/
private void setDirty (@Nonnull final Dirty dirty)
{
this.dirty = dirty;
setNeedsLayout(true);
}
}