elements) {
this.elements = elements;
}
public Layer add(MapObject element) {
element.setLayer(this);
elements = add(elements, element);
return this;
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/JMapController.java 0000644 0000000 0000000 00000002117 12475707776 025274 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseWheelListener;
/**
* Abstract base class for all mouse controller implementations. For
* implementing your own controller create a class that derives from this one
* and implements one or more of the following interfaces:
*
* - {@link MouseListener}
* - {@link MouseMotionListener}
* - {@link MouseWheelListener}
*
*
* @author Jan Peter Stotz
*/
public abstract class JMapController {
protected JMapViewer map;
public JMapController(JMapViewer map) {
this.map = map;
if (this instanceof MouseListener)
map.addMouseListener((MouseListener) this);
if (this instanceof MouseWheelListener)
map.addMouseWheelListener((MouseWheelListener) this);
if (this instanceof MouseMotionListener)
map.addMouseMotionListener((MouseMotionListener) this);
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/events/ 0000755 0000000 0000000 00000000000 12604423574 023022 5 ustar root root jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/events/JMVCommandEvent.java 0000644 0000000 0000000 00000001755 12604423574 026632 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.events;
import java.util.EventObject;
/**
* Used for passing events between UI components and other
* objects that register as a JMapViewerEventListener
*
* @author Jason Huntley
*
*/
public class JMVCommandEvent extends EventObject {
public enum COMMAND {
MOVE,
ZOOM
}
private COMMAND command;
/**
*
*/
private static final long serialVersionUID = 8701544867914969620L;
public JMVCommandEvent(COMMAND cmd, Object source) {
super(source);
setCommand(cmd);
}
public JMVCommandEvent(Object source) {
super(source);
}
/**
* @return the command
*/
public COMMAND getCommand() {
return command;
}
/**
* @param command the command to set
*/
public void setCommand(COMMAND command) {
this.command = command;
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/MapMarkerDot.java 0000644 0000000 0000000 00000003301 12566160376 024711 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import java.awt.Color;
import org.openstreetmap.gui.jmapviewer.interfaces.MapMarker;
/**
* A simple implementation of the {@link MapMarker} interface. Each map marker
* is painted as a circle with a black border line and filled with a specified
* color.
*
* @author Jan Peter Stotz
*
*/
public class MapMarkerDot extends MapMarkerCircle {
public static final int DOT_RADIUS = 5;
public MapMarkerDot(Coordinate coord) {
this(null, null, coord);
}
public MapMarkerDot(String name, Coordinate coord) {
this(null, name, coord);
}
public MapMarkerDot(Layer layer, Coordinate coord) {
this(layer, null, coord);
}
public MapMarkerDot(Layer layer, String name, Coordinate coord) {
this(layer, name, coord, getDefaultStyle());
}
public MapMarkerDot(Color color, double lat, double lon) {
this(null, null, lat, lon);
setColor(color);
}
public MapMarkerDot(double lat, double lon) {
this(null, null, lat, lon);
}
public MapMarkerDot(Layer layer, double lat, double lon) {
this(layer, null, lat, lon);
}
public MapMarkerDot(Layer layer, String name, double lat, double lon) {
this(layer, name, new Coordinate(lat, lon), getDefaultStyle());
}
public MapMarkerDot(Layer layer, String name, Coordinate coord, Style style) {
super(layer, name, coord, DOT_RADIUS, STYLE.FIXED, style);
}
public static Style getDefaultStyle() {
return new Style(Color.BLACK, Color.YELLOW, null, getDefaultFont());
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/OsmMercator.java 0000644 0000000 0000000 00000015775 12566160376 024640 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
/**
* This class implements the Mercator Projection as it is used by OpenStreetMap
* (and google). It provides methods to translate coordinates from 'map space'
* into latitude and longitude (on the WGS84 ellipsoid) and vice versa. Map
* space is measured in pixels. The origin of the map space is the top left
* corner. The map space origin (0,0) has latitude ~85 and longitude -180.
* @author Jan Peter Stotz
* @author Jason Huntley
*/
public class OsmMercator {
/**
* default tile size
*/
public static final int DEFAUL_TILE_SIZE = 256;
/** maximum latitude (north) for mercator display */
public static final double MAX_LAT = 85.05112877980659;
/** minimum latitude (south) for mercator display */
public static final double MIN_LAT = -85.05112877980659;
/** equatorial earth radius for EPSG:3857 (Mercator) */
private static double EARTH_RADIUS = 6378137;
/**
* instance with tile size of 256 for easy conversions
*/
public static final OsmMercator MERCATOR_256 = new OsmMercator();
/** tile size of the displayed tiles */
private int tileSize = DEFAUL_TILE_SIZE;
/**
* Creates instance with default tile size of 256
*/
public OsmMercator() {
}
/**
* Creates instance with provided tile size.
* @param tileSize tile size in pixels
*/
public OsmMercator(int tileSize) {
this.tileSize = tileSize;
}
public double radius(int aZoomlevel) {
return (tileSize * (1 << aZoomlevel)) / (2.0 * Math.PI);
}
/**
* Returns the absolut number of pixels in y or x, defined as: 2^Zoomlevel *
* tileSize where tileSize is the width of a tile in pixels
*
* @param aZoomlevel zoom level to request pixel data
* @return number of pixels
*/
public int getMaxPixels(int aZoomlevel) {
return tileSize * (1 << aZoomlevel);
}
public int falseEasting(int aZoomlevel) {
return getMaxPixels(aZoomlevel) / 2;
}
public int falseNorthing(int aZoomlevel) {
return -1 * getMaxPixels(aZoomlevel) / 2;
}
/**
* Transform pixelspace to coordinates and get the distance.
*
* @param x1 the first x coordinate
* @param y1 the first y coordinate
* @param x2 the second x coordinate
* @param y2 the second y coordinate
*
* @param zoomLevel the zoom level
* @return the distance
*/
public double getDistance(int x1, int y1, int x2, int y2, int zoomLevel) {
double la1 = yToLat(y1, zoomLevel);
double lo1 = xToLon(x1, zoomLevel);
double la2 = yToLat(y2, zoomLevel);
double lo2 = xToLon(x2, zoomLevel);
return getDistance(la1, lo1, la2, lo2);
}
/**
* Gets the distance using Spherical law of cosines.
*
* @param la1 the Latitude in degrees
* @param lo1 the Longitude in degrees
* @param la2 the Latitude from 2nd coordinate in degrees
* @param lo2 the Longitude from 2nd coordinate in degrees
* @return the distance
*/
public double getDistance(double la1, double lo1, double la2, double lo2) {
double aStartLat = Math.toRadians(la1);
double aStartLong = Math.toRadians(lo1);
double aEndLat = Math.toRadians(la2);
double aEndLong = Math.toRadians(lo2);
double distance = Math.acos(Math.sin(aStartLat) * Math.sin(aEndLat)
+ Math.cos(aStartLat) * Math.cos(aEndLat)
* Math.cos(aEndLong - aStartLong));
return EARTH_RADIUS * distance;
}
/**
* Transform longitude to pixelspace
*
*
* Mathematical optimization
*
* x = radius(aZoomlevel) * toRadians(aLongitude) + falseEasting(aZoomLevel)
* x = getMaxPixels(aZoomlevel) / (2 * PI) * (aLongitude * PI) / 180 + getMaxPixels(aZoomlevel) / 2
* x = getMaxPixels(aZoomlevel) * aLongitude / 360 + 180 * getMaxPixels(aZoomlevel) / 360
* x = getMaxPixels(aZoomlevel) * (aLongitude + 180) / 360
*
*
*
* @param aLongitude
* [-180..180]
* @param aZoomlevel zoom level
* @return [0..2^Zoomlevel*TILE_SIZE[
*/
public double lonToX(double aLongitude, int aZoomlevel) {
int mp = getMaxPixels(aZoomlevel);
double x = (mp * (aLongitude + 180L)) / 360L;
return Math.min(x, mp);
}
/**
* Transforms latitude to pixelspace
*
* Mathematical optimization
*
* log(u) := log((1.0 + sin(toRadians(aLat))) / (1.0 - sin(toRadians(aLat))
*
* y = -1 * (radius(aZoomlevel) / 2 * log(u)))) - falseNorthing(aZoomlevel))
* y = -1 * (getMaxPixel(aZoomlevel) / 2 * PI / 2 * log(u)) - -1 * getMaxPixel(aZoomLevel) / 2
* y = getMaxPixel(aZoomlevel) / (-4 * PI) * log(u)) + getMaxPixel(aZoomLevel) / 2
* y = getMaxPixel(aZoomlevel) * ((log(u) / (-4 * PI)) + 1/2)
*
*
* @param aLat
* [-90...90]
* @param aZoomlevel zoom level
* @return [0..2^Zoomlevel*TILE_SIZE[
*/
public double latToY(double aLat, int aZoomlevel) {
if (aLat < MIN_LAT)
aLat = MIN_LAT;
else if (aLat > MAX_LAT)
aLat = MAX_LAT;
double sinLat = Math.sin(Math.toRadians(aLat));
double log = Math.log((1.0 + sinLat) / (1.0 - sinLat));
int mp = getMaxPixels(aZoomlevel);
double y = mp * (0.5 - (log / (4.0 * Math.PI)));
return Math.min(y, mp - 1);
}
/**
* Transforms pixel coordinate X to longitude
*
*
* Mathematical optimization
*
* lon = toDegree((aX - falseEasting(aZoomlevel)) / radius(aZoomlevel))
* lon = 180 / PI * ((aX - getMaxPixels(aZoomlevel) / 2) / getMaxPixels(aZoomlevel) / (2 * PI)
* lon = 180 * ((aX - getMaxPixels(aZoomlevel) / 2) / getMaxPixels(aZoomlevel))
* lon = 360 / getMaxPixels(aZoomlevel) * (aX - getMaxPixels(aZoomlevel) / 2)
* lon = 360 * aX / getMaxPixels(aZoomlevel) - 180
*
*
* @param aX
* [0..2^Zoomlevel*TILE_WIDTH[
* @param aZoomlevel zoom level
* @return ]-180..180[
*/
public double xToLon(int aX, int aZoomlevel) {
return ((360d * aX) / getMaxPixels(aZoomlevel)) - 180.0;
}
/**
* Transforms pixel coordinate Y to latitude
*
* @param aY
* [0..2^Zoomlevel*TILE_WIDTH[
* @param aZoomlevel zoom level
* @return [MIN_LAT..MAX_LAT] is about [-85..85]
*/
public double yToLat(int aY, int aZoomlevel) {
aY += falseNorthing(aZoomlevel);
double latitude = (Math.PI / 2) - (2 * Math.atan(Math.exp(-1.0 * aY / radius(aZoomlevel))));
return -1 * Math.toDegrees(latitude);
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/AbstractLayer.java 0000644 0000000 0000000 00000005177 12566160406 025132 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import java.util.ArrayList;
import java.util.List;
public class AbstractLayer {
private LayerGroup parent;
private String name;
private String description;
private Style style;
private Boolean visible;
private Boolean visibleTexts = Boolean.TRUE;
public AbstractLayer(String name) {
this(name, (String) null);
}
public AbstractLayer(String name, String description) {
this(name, description, MapMarkerCircle.getDefaultStyle());
}
public AbstractLayer(String name, Style style) {
this(name, null, style);
}
public AbstractLayer(String name, String description, Style style) {
this(null, name, description, style);
}
public AbstractLayer(LayerGroup parent, String name) {
this(parent, name, MapMarkerCircle.getDefaultStyle());
}
public AbstractLayer(LayerGroup parent, String name, Style style) {
this(parent, name, null, style);
}
public AbstractLayer(LayerGroup parent, String name, String description, Style style) {
setParent(parent);
setName(name);
setDescription(description);
setStyle(style);
setVisible(Boolean.TRUE);
if (parent != null) parent.add(this);
}
public LayerGroup getParent() {
return parent;
}
public void setParent(LayerGroup parent) {
this.parent = parent;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Style getStyle() {
return style;
}
public void setStyle(Style style) {
this.style = style;
}
public Boolean isVisible() {
return visible;
}
public void setVisible(Boolean visible) {
this.visible = visible;
}
public static List add(List list, E element) {
if (element != null) {
if (list == null) list = new ArrayList<>();
if (!list.contains(element)) list.add(element);
}
return list;
}
public Boolean isVisibleTexts() {
return visibleTexts;
}
public void setVisibleTexts(Boolean visibleTexts) {
this.visibleTexts = visibleTexts;
}
@Override
public String toString() {
return name;
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/JMapViewerTree.java 0000644 0000000 0000000 00000014512 12641052742 025211 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.List;
import javax.swing.JLabel;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JSplitPane;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import org.openstreetmap.gui.jmapviewer.checkBoxTree.CheckBoxNodePanel;
import org.openstreetmap.gui.jmapviewer.checkBoxTree.CheckBoxTree;
import org.openstreetmap.gui.jmapviewer.interfaces.MapObject;
/**
* Tree of layers for JMapViewer component
* @author galo
*/
public class JMapViewerTree extends JPanel {
/** Serial Version UID */
private static final long serialVersionUID = 3050203054402323972L;
private JMapViewer map;
private CheckBoxTree tree;
private JPanel treePanel;
private JSplitPane splitPane;
public JMapViewerTree(String name) {
this(name, false);
}
public JMapViewerTree(String name, boolean treeVisible) {
super();
splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
tree = new CheckBoxTree(name);
treePanel = new JPanel();
treePanel.setLayout(new BorderLayout());
treePanel.add(tree, BorderLayout.CENTER);
treePanel.add(new JLabel("Use right mouse button to
show/hide texts"), BorderLayout.SOUTH);
map = new JMapViewer();
splitPane.setOneTouchExpandable(true);
splitPane.setDividerLocation(150);
//Provide minimum sizes for the two components in the split pane
Dimension minimumSize = new Dimension(100, 50);
//tree.setMinimumSize(minimumSize);
map.setMinimumSize(minimumSize);
createRefresh();
setLayout(new BorderLayout());
setTreeVisible(treeVisible);
tree.addNodeListener(new MouseAdapter() {
@Override
public void mousePressed(MouseEvent e) {
maybeShowPopup(e);
}
@Override
public void mouseReleased(MouseEvent e) {
maybeShowPopup(e);
}
private void maybeShowPopup(MouseEvent e) {
if (e.isPopupTrigger()) {
AbstractLayer layer = ((CheckBoxNodePanel) e.getComponent()).getData().getAbstractLayer();
if (layer != null)
JMapViewerTree.this.createPopupMenu(layer).show(e.getComponent(), e.getX(), e.getY());
}
}
});
}
private JPopupMenu createPopupMenu(final AbstractLayer layer) {
JMenuItem menuItemShow = new JMenuItem("show texts");
JMenuItem menuItemHide = new JMenuItem("hide texts");
//Create the popup menu.
JPopupMenu popup = new JPopupMenu();
// Create items
if (layer.isVisibleTexts() == null) {
popup.add(menuItemShow);
popup.add(menuItemHide);
} else if (layer.isVisibleTexts()) popup.add(menuItemHide);
else popup.add(menuItemShow);
menuItemShow.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
setVisibleTexts(layer, true);
if (layer.getParent() != null) layer.getParent().calculateVisibleTexts();
map.repaint();
}
});
menuItemHide.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
setVisibleTexts(layer, false);
if (layer.getParent() != null) layer.getParent().calculateVisibleTexts();
map.repaint();
}
});
return popup;
}
private static void setVisibleTexts(AbstractLayer layer, boolean visible) {
layer.setVisibleTexts(visible);
if (layer instanceof LayerGroup) {
LayerGroup group = (LayerGroup) layer;
if (group.getLayers() != null)
for (AbstractLayer al: group.getLayers()) {
setVisibleTexts(al, visible);
}
}
}
public Layer addLayer(String name) {
Layer layer = new Layer(name);
this.addLayer(layer);
return layer;
}
public JMapViewerTree addLayer(Layer layer) {
tree.addLayer(layer);
return this;
}
public JMapViewerTree addLayer(MapObject element) {
//element.getLayer().add(element);
return addLayer(element.getLayer());
}
public Layer removeFromLayer(MapObject element) {
element.getLayer().getElements().remove(element);
return element.getLayer();
}
public static int size(List list) {
return list == null ? 0 : list.size();
}
public JMapViewer getViewer() {
return map;
}
public CheckBoxTree getTree() {
return tree;
}
public void addMapObject(MapObject o){
}
public void setTreeVisible(boolean visible) {
removeAll();
revalidate();
if (visible) {
splitPane.setLeftComponent(treePanel);
splitPane.setRightComponent(map);
add(splitPane, BorderLayout.CENTER);
} else add(map, BorderLayout.CENTER);
repaint();
}
private void createRefresh() {
tree.getModel().addTreeModelListener(new TreeModelListener() {
@Override
public void treeNodesChanged(final TreeModelEvent e) {
repaint();
}
@Override
public void treeNodesInserted(TreeModelEvent arg0) {
// TODO Auto-generated method stub
}
@Override
public void treeNodesRemoved(TreeModelEvent arg0) {
// TODO Auto-generated method stub
}
@Override
public void treeStructureChanged(TreeModelEvent arg0) {
// TODO Auto-generated method stub
}
});
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/MemoryTileCache.java 0000644 0000000 0000000 00000014526 12641052742 025377 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;
import org.openstreetmap.gui.jmapviewer.interfaces.TileCache;
import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
/**
* {@link TileCache} implementation that stores all {@link Tile} objects in
* memory up to a certain limit ({@link #getCacheSize()}). If the limit is
* exceeded the least recently used {@link Tile} objects will be deleted.
*
* @author Jan Peter Stotz
*/
public class MemoryTileCache implements TileCache {
protected static final Logger log = Logger.getLogger(MemoryTileCache.class.getName());
/**
* Default cache size
*/
protected int cacheSize;
protected final Map hash;
/**
* List of all tiles in their last recently used order
*/
protected final CacheLinkedListElement lruTiles;
/**
* Constructs a new {@code MemoryTileCache}.
*/
public MemoryTileCache() {
this(200);
}
/**
* Constructs a new {@code MemoryTileCache}.
* @param cacheSize size of the cache
*/
public MemoryTileCache(int cacheSize) {
this.cacheSize = cacheSize;
hash = new HashMap<>(cacheSize);
lruTiles = new CacheLinkedListElement();
}
@Override
public synchronized void addTile(Tile tile) {
CacheEntry entry = createCacheEntry(tile);
if (hash.put(tile.getKey(), entry) == null) {
// only if hash hadn't had the element, add it to LRU
lruTiles.addFirst(entry);
if (hash.size() > cacheSize || lruTiles.getElementCount() > cacheSize) {
removeOldEntries();
}
}
}
@Override
public synchronized Tile getTile(TileSource source, int x, int y, int z) {
CacheEntry entry = hash.get(Tile.getTileKey(source, x, y, z));
if (entry == null)
return null;
lruTiles.moveElementToFirstPos(entry);
return entry.tile;
}
/**
* Removes the least recently used tiles
*/
protected synchronized void removeOldEntries() {
try {
while (lruTiles.getElementCount() > cacheSize) {
removeEntry(lruTiles.getLastElement());
}
} catch (Exception e) {
log.warning(e.getMessage());
}
}
protected synchronized void removeEntry(CacheEntry entry) {
hash.remove(entry.tile.getKey());
lruTiles.removeEntry(entry);
}
protected CacheEntry createCacheEntry(Tile tile) {
return new CacheEntry(tile);
}
@Override
public synchronized void clear() {
hash.clear();
lruTiles.clear();
}
@Override
public synchronized int getTileCount() {
return hash.size();
}
@Override
public synchronized int getCacheSize() {
return cacheSize;
}
/**
* Changes the maximum number of {@link Tile} objects that this cache holds.
*
* @param cacheSize
* new maximum number of tiles
*/
public synchronized void setCacheSize(int cacheSize) {
this.cacheSize = cacheSize;
if (hash.size() > cacheSize)
removeOldEntries();
}
/**
* Linked list element holding the {@link Tile} and links to the
* {@link #next} and {@link #prev} item in the list.
*/
protected static class CacheEntry {
private Tile tile;
private CacheEntry next;
private CacheEntry prev;
protected CacheEntry(Tile tile) {
this.tile = tile;
}
}
/**
* Special implementation of a double linked list for {@link CacheEntry}
* elements. It supports element removal in constant time - in difference to
* the Java implementation which needs O(n).
*
* @author Jan Peter Stotz
*/
protected static class CacheLinkedListElement {
protected CacheEntry firstElement;
protected CacheEntry lastElement;
protected int elementCount;
/**
* Constructs a new {@code CacheLinkedListElement}.
*/
public CacheLinkedListElement() {
clear();
}
public void clear() {
elementCount = 0;
firstElement = null;
lastElement = null;
}
/**
* Add the element to the head of the list.
*
* @param element new element to be added
*/
public void addFirst(CacheEntry element) {
if (element == null) return;
if (elementCount == 0) {
firstElement = element;
lastElement = element;
element.prev = null;
element.next = null;
} else {
element.next = firstElement;
firstElement.prev = element;
element.prev = null;
firstElement = element;
}
elementCount++;
}
/**
* Removes the specified element from the list.
*
* @param element element to be removed
*/
public void removeEntry(CacheEntry element) {
if (element == null) return;
if (element.next != null) {
element.next.prev = element.prev;
}
if (element.prev != null) {
element.prev.next = element.next;
}
if (element == firstElement)
firstElement = element.next;
if (element == lastElement)
lastElement = element.prev;
element.next = null;
element.prev = null;
elementCount--;
}
public void moveElementToFirstPos(CacheEntry entry) {
if (firstElement == entry)
return;
removeEntry(entry);
addFirst(entry);
}
public int getElementCount() {
return elementCount;
}
public CacheEntry getLastElement() {
return lastElement;
}
public CacheEntry getFirstElement() {
return firstElement;
}
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/ 0000755 0000000 0000000 00000000000 12641052742 024053 5 ustar root root jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/TileSourceInfo.java 0000644 0000000 0000000 00000010757 12641052742 027622 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.tilesources;
import java.util.Map;
import org.openstreetmap.gui.jmapviewer.OsmMercator;
/**
* Data class that keeps basic information about a tile source.
*
* @since 31122
*/
public class TileSourceInfo {
/** id for this imagery entry, optional at the moment */
protected String id;
/** URL of the imagery service */
protected String url;
/** name of the imagery layer */
protected String name;
/** headers meaning, that there is no tile at this zoom level */
protected Map noTileHeaders;
/** minimum zoom level supported by the tile source */
protected int minZoom;
/** maximum zoom level supported by the tile source */
protected int maxZoom;
/** cookies that needs to be sent to tile source */
protected String cookies = "";
/** tile size of the displayed tiles */
private int tileSize = OsmMercator.DEFAUL_TILE_SIZE; // FIXME: set to -1 for next release
/** mapping <header key, metadata key> */
protected Map metadataHeaders;
/**
* Create a TileSourceInfo class
*
* @param name name
* @param baseUrl base URL
* @param id unique id
*/
public TileSourceInfo(String name, String baseUrl, String id) {
this.name = name;
this.url = baseUrl;
this.id = id;
}
/**
* Create a TileSourceInfo class
*
* @param name name
*/
public TileSourceInfo(String name) {
this(name, null, null);
}
/**
* Creates empty TileSourceInfo class
*/
public TileSourceInfo() {
this(null, null, null);
}
/**
* Request name of the tile source
* @return name of the tile source
*/
public final String getName() {
return name;
}
/**
* Request URL of the tile source
* @return url of the tile source
*/
public final String getUrl() {
return url;
}
/**
* Request ID of the tile source. Id can be null. This gets the configured id as is.
* Due to a user error, this may not be unique.
* @return id of the tile source
*/
public final String getId() {
return id;
}
/**
* Request header information for empty tiles for servers delivering such tile types
* @return map of headers, that when set, means that this is "no tile at this zoom level" situation
*/
public Map getNoTileHeaders() {
return noTileHeaders;
}
/**
* Request supported minimum zoom level
* @return minimum zoom level supported by tile source
*/
public int getMinZoom() {
return minZoom;
}
/**
* Request supported maximum zoom level
* @return maximum zoom level supported by tile source
*/
public int getMaxZoom() {
return maxZoom;
}
/**
* Request cookies to be sent together with request
* @return cookies to be sent along with request to tile source
*/
public String getCookies() {
return cookies;
}
/**
* Request tile size of this tile source
* @return tile size provided by this tile source, or -1 when default value should be used
*/
public int getTileSize() {
return tileSize;
}
/**
* Request metadata headers
* @return mapping <HTTP header name, Metadata key name> for copying HTTP headers to Tile metadata
* @since 31125
*/
public Map getMetadataHeaders() {
return metadataHeaders;
}
/**
* Sets the tile size provided by this tile source
* @param tileSize tile size in pixels
*/
public final void setTileSize(int tileSize) {
if (tileSize == 0 || tileSize < -1) {
throw new AssertionError("Invalid tile size: " + tileSize);
}
this.tileSize = tileSize;
}
/**
* Sets the tile URL.
* @param url tile URL
*/
public final void setUrl(String url) {
this.url = url;
}
/**
* Sets the tile name.
* @param name tile name
*/
public final void setName(String name) {
this.name = name;
}
/**
* Sets the tile id.
* @param id tile id
*/
public final void setId(String id) {
this.id = id;
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/AbstractMapQuestTileSource.java 0000644 0000000 0000000 00000005025 12641052742 032142 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.tilesources;
import java.awt.Image;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.xml.bind.DatatypeConverter;
public class AbstractMapQuestTileSource extends AbstractOsmTileSource {
// MapQuest logo in base64: http://developer.mapquest.com/content/osm/mq_logo.png
private static final String LOGO_BASE64 =
"iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJl"+
"YWR5ccllPAAAAZtJREFUeNpi/P//P0PPcYf/DGSAEssDjIzdx+zJ0gwDLMQqVBWyZVAStGRgBMK33x8wnH62"+
"kngD+DmkGBwUshn42SXA/P8M/xg+/3rDcOPNPuIMMJeKAmv+8OMpw7ffHxikeLUZXBTzgez3DEzEGMDGzAmm"+
"jz5ewLDqWiHE6UwcDHxsYhAXsLPwMFhKxzIIccozPP18ieHhx3MMGsKOYP7td4fBzgUBN+ViBkeFLDD7zbf7"+
"DK++3WFgAMXC448X/uMDV17t+H/r7UEM8VNPl/8Hu0CGTx9s6tXXOxhEuJQYxLnVgK44w/Dzz1cGNWF7BlGg"+
"2KJLqQzCQBcxMbEw/P77g0FTxBkYJs8gXgCFKiMwOLbf6WDQF/djcFUqAvv33fdHYAM4WPjAFrz9/hAeLsef"+
"LALT4EBkhIYlMxMrAxerIJjNCdTExy4OZv/59xNnAKPEAh+bBNAQSMwKcsgAQ5odzBbilGNghcYE1pS4+14f"+
"MKq4GP79/w1OHCC/v/x6Exzv+x9MhbiOEeh3LAZQnBeYGCgEjJRmZ4AAAwCE6rplT3Ba/gAAAABJRU5ErkJg"+
"gg==";
protected static final String MAPQUEST_ATTRIBUTION = "Tiles Courtesy of MapQuest ";
protected static final String MAPQUEST_WEBSITE = "http://www.mapquest.com";
private static final int NUMBER_OF_SERVERS = 4;
private int SERVER_NUM = 1;
public AbstractMapQuestTileSource(String name, String baseUrl, String id) {
super(name, baseUrl, id);
}
@Override
public String getBaseUrl() {
String url = String.format(this.baseUrl, SERVER_NUM);
SERVER_NUM = (SERVER_NUM % NUMBER_OF_SERVERS) + 1;
return url;
}
@Override
public Image getAttributionImage() {
try {
return ImageIO.read(new ByteArrayInputStream(DatatypeConverter.parseBase64Binary(LOGO_BASE64)));
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
@Override
public String getAttributionImageURL() {
return MAPQUEST_WEBSITE;
}
/* (non-Javadoc)
* @see org.openstreetmap.gui.jmapviewer.tilesources.AbstractOsmTileSource#getTermsOfUseURL()
*/
@Override
public String getTermsOfUseURL() {
return "http://developer.mapquest.com/web/products/open/map#terms";
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/ScanexTileSource.java 0000644 0000000 0000000 00000010523 12641052742 030137 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.tilesources;
import java.util.Random;
import org.openstreetmap.gui.jmapviewer.OsmMercator;
/**
* This tilesource uses different to OsmMercator projection.
*
* Earth is assumed an ellipsoid in this projection, unlike
* sphere in OsmMercator, so latitude calculation differs a lot.
*
* The longitude calculation is the same as in OsmMercator,
* we inherit it from AbstractTMSTileSource.
*
* TODO: correct getDistance() method.
*/
public class ScanexTileSource extends TMSTileSource {
private static final String DEFAULT_URL = "http://maps.kosmosnimki.ru";
private static final int DEFAULT_MAXZOOM = 14;
private static final String API_KEY = "4018C5A9AECAD8868ED5DEB2E41D09F7";
// Latitude to Y and back calculations.
/** radius of Earth at equator, m */
private static double RADIUS_E = 6378137;
/** equator length, m */
private static double EQUATOR = 40075016.68557849;
/** eccentricity of Earth's ellipsoid */
private static double E = 0.0818191908426;
private enum ScanexLayer {
IRS("irs", "/TileSender.ashx?ModeKey=tile&MapName=F7B8CF651682420FA1749D894C8AD0F6&LayerName=BAC78D764F0443BD9AF93E7A998C9F5B"),
SPOT("spot", "/TileSender.ashx?ModeKey=tile&MapName=F7B8CF651682420FA1749D894C8AD0F6&LayerName=F51CE95441284AF6B2FC319B609C7DEC");
private String name;
private String uri;
ScanexLayer(String name, String uri) {
this.name = name;
this.uri = uri;
}
public String getName() {
return name;
}
public String getUri() {
return uri;
}
}
/** IRS by default */
private ScanexLayer layer = ScanexLayer.IRS;
/** cached latitude used in {@link #tileYToLat(double, int)} */
private double cachedLat;
/**
* Constructs a new {@code ScanexTileSource}.
* @param info tile source info
*/
public ScanexTileSource(TileSourceInfo info) {
super(info);
String url = info.getUrl();
for (ScanexLayer slayer : ScanexLayer.values()) {
if (url.equalsIgnoreCase(slayer.getName())) {
this.layer = slayer;
// Override baseUrl and maxZoom in base class.
this.baseUrl = DEFAULT_URL;
if (maxZoom == 0)
this.maxZoom = DEFAULT_MAXZOOM;
break;
}
}
}
@Override
public String getExtension() {
return "jpeg";
}
@Override
public String getTilePath(int zoom, int tilex, int tiley) {
int tmp = (int) Math.pow(2.0, zoom - 1);
tilex = tilex - tmp;
tiley = tmp - tiley - 1;
return this.layer.getUri() + "&apikey=" + API_KEY + "&x=" + tilex + "&y=" + tiley + "&z=" + zoom;
}
/*
* To solve inverse formula latitude = f(y) we use
* Newton's method. We cache previous calculated latitude,
* because new one is usually close to the old one. In case
* if solution gets out of bounds, we reset to a new random value.
*/
private double tileYToLat(double y, int zoom) {
double lat0;
double lat = cachedLat;
do {
lat0 = lat;
lat = lat - Math.toDegrees(nextTerm(Math.toRadians(lat), y, zoom));
if (lat > OsmMercator.MAX_LAT || lat < OsmMercator.MIN_LAT) {
Random r = new Random();
lat = OsmMercator.MIN_LAT +
r.nextInt((int) (OsmMercator.MAX_LAT - OsmMercator.MIN_LAT));
}
} while (Math.abs(lat0 - lat) > 0.000001);
cachedLat = lat;
return lat;
}
/* Next term in Newton's polynomial */
private static double nextTerm(double lat, double y, int zoom) {
double sinl = Math.sin(lat);
double cosl = Math.cos(lat);
zoom = (int) Math.pow(2.0, zoom - 1);
double ec = Math.exp((1 - y/zoom)*Math.PI);
double f = Math.tan(Math.PI/4+lat/2) -
ec * Math.pow(Math.tan(Math.PI/4 + Math.asin(E * sinl)/2), E);
double df = 1/(1 - sinl) - ec * E * cosl/((1 - E * sinl) *
(Math.sqrt(1 - E * E * sinl * sinl)));
return f/df;
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/MapQuestOsmTileSource.java 0000644 0000000 0000000 00000001241 12566160376 031142 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.tilesources;
import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
public class MapQuestOsmTileSource extends AbstractMapQuestTileSource {
private static final String PATTERN = "http://otile%d.mqcdn.com/tiles/1.0.0/osm";
public MapQuestOsmTileSource() {
super("MapQuest-OSM", PATTERN, "mapquest-osm");
}
@Override
public String getAttributionText(int zoom, ICoordinate topLeft,
ICoordinate botRight) {
return super.getAttributionText(zoom, topLeft, botRight)+" - "+MAPQUEST_ATTRIBUTION;
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/AbstractTMSTileSource.java 0000644 0000000 0000000 00000016165 12604423574 031061 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.tilesources;
import java.awt.Point;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.openstreetmap.gui.jmapviewer.Coordinate;
import org.openstreetmap.gui.jmapviewer.OsmMercator;
import org.openstreetmap.gui.jmapviewer.Tile;
import org.openstreetmap.gui.jmapviewer.TileXY;
import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
/**
* Class generalizing all tile based tile sources
*
* @author Wiktor Niesiobędzki
*
*/
public abstract class AbstractTMSTileSource extends AbstractTileSource {
protected String name;
protected String baseUrl;
protected String id;
private final Map noTileHeaders;
private final Map metadataHeaders;
protected int tileSize;
protected OsmMercator osmMercator;
/**
* Creates an instance based on TileSource information
*
* @param info description of the Tile Source
*/
public AbstractTMSTileSource(TileSourceInfo info) {
this.name = info.getName();
this.baseUrl = info.getUrl();
if (baseUrl != null && baseUrl.endsWith("/")) {
baseUrl = baseUrl.substring(0, baseUrl.length()-1);
}
this.id = info.getUrl();
this.noTileHeaders = info.getNoTileHeaders();
this.metadataHeaders = info.getMetadataHeaders();
this.tileSize = info.getTileSize();
this.osmMercator = new OsmMercator(this.tileSize);
}
/**
* @return default tile size to use, when not set in Imagery Preferences
*/
@Override
public int getDefaultTileSize() {
return OsmMercator.DEFAUL_TILE_SIZE;
}
@Override
public String getName() {
return name;
}
@Override
public String getId() {
return id;
}
@Override
public int getMaxZoom() {
return 21;
}
@Override
public int getMinZoom() {
return 0;
}
/**
* @return image extension, used for URL creation
*/
public String getExtension() {
return "png";
}
/**
* @param zoom level of the tile
* @param tilex tile number in x axis
* @param tiley tile number in y axis
* @return String containg path part of URL of the tile
* @throws IOException when subclass cannot return the tile URL
*/
public String getTilePath(int zoom, int tilex, int tiley) throws IOException {
return "/" + zoom + "/" + tilex + "/" + tiley + "." + getExtension();
}
/**
* @return Base part of the URL of the tile source
*/
public String getBaseUrl() {
return this.baseUrl;
}
@Override
public String getTileUrl(int zoom, int tilex, int tiley) throws IOException {
return this.getBaseUrl() + getTilePath(zoom, tilex, tiley);
}
@Override
public String toString() {
return getName();
}
/*
* Most tilesources use OsmMercator projection.
*/
@Override
public int getTileSize() {
if (tileSize <= 0) {
return getDefaultTileSize();
}
return tileSize;
}
@Override
public double getDistance(double lat1, double lon1, double lat2, double lon2) {
return osmMercator.getDistance(lat1, lon1, lat2, lon2);
}
@Override
public Point latLonToXY(double lat, double lon, int zoom) {
return new Point(
(int) osmMercator.lonToX(lon, zoom),
(int) osmMercator.latToY(lat, zoom)
);
}
@Override
public Point latLonToXY(ICoordinate point, int zoom) {
return latLonToXY(point.getLat(), point.getLon(), zoom);
}
@Override
public ICoordinate xyToLatLon(Point point, int zoom) {
return xyToLatLon(point.x, point.y, zoom);
}
@Override
public ICoordinate xyToLatLon(int x, int y, int zoom) {
return new Coordinate(
osmMercator.yToLat(y, zoom),
osmMercator.xToLon(x, zoom)
);
}
@Override
public TileXY latLonToTileXY(double lat, double lon, int zoom) {
return new TileXY(
osmMercator.lonToX(lon, zoom) / tileSize,
osmMercator.latToY(lat, zoom) / tileSize
);
}
@Override
public TileXY latLonToTileXY(ICoordinate point, int zoom) {
return latLonToTileXY(point.getLat(), point.getLon(), zoom);
}
@Override
public ICoordinate tileXYToLatLon(TileXY xy, int zoom) {
return tileXYToLatLon(xy.getXIndex(), xy.getYIndex(), zoom);
}
@Override
public ICoordinate tileXYToLatLon(Tile tile) {
return tileXYToLatLon(tile.getXtile(), tile.getYtile(), tile.getZoom());
}
@Override
public ICoordinate tileXYToLatLon(int x, int y, int zoom) {
return new Coordinate(
osmMercator.yToLat(y * tileSize, zoom),
osmMercator.xToLon(x * tileSize, zoom)
);
}
@Override
public int getTileXMax(int zoom) {
return getTileMax(zoom);
}
@Override
public int getTileXMin(int zoom) {
return 0;
}
@Override
public int getTileYMax(int zoom) {
return getTileMax(zoom);
}
@Override
public int getTileYMin(int zoom) {
return 0;
}
@Override
public boolean isNoTileAtZoom(Map> headers, int statusCode, byte[] content) {
if (noTileHeaders != null && headers != null) {
for (Entry searchEntry: noTileHeaders.entrySet()) {
List headerVals = headers.get(searchEntry.getKey());
if (headerVals != null) {
for (String headerValue: headerVals) {
if (headerValue.matches(searchEntry.getValue())) {
return true;
}
}
}
}
}
return super.isNoTileAtZoom(headers, statusCode, content);
}
@Override
public Map getMetadata(Map> headers) {
Map ret = new HashMap<>();
if (metadataHeaders != null && headers != null) {
for (Entry searchEntry: metadataHeaders.entrySet()) {
List headerVals = headers.get(searchEntry.getKey());
if (headerVals != null) {
for (String headerValue: headerVals) {
ret.put(searchEntry.getValue(), headerValue);
}
}
}
}
return ret;
}
@Override
public String getTileId(int zoom, int tilex, int tiley) {
return this.baseUrl + "/" + zoom + "/" + tilex + "/" + tiley;
}
private static int getTileMax(int zoom) {
return (int) Math.pow(2.0, zoom) - 1;
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/TMSTileSource.java 0000644 0000000 0000000 00000001156 12641052742 027363 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.tilesources;
public class TMSTileSource extends AbstractTMSTileSource {
protected int maxZoom;
protected int minZoom;
public TMSTileSource(TileSourceInfo info) {
super(info);
minZoom = info.getMinZoom();
maxZoom = info.getMaxZoom();
}
@Override
public int getMinZoom() {
return (minZoom == 0) ? super.getMinZoom() : minZoom;
}
@Override
public int getMaxZoom() {
return (maxZoom == 0) ? super.getMaxZoom() : maxZoom;
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/TemplatedTMSTileSource.java 0000644 0000000 0000000 00000012360 12641052742 031222 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.tilesources;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.openstreetmap.gui.jmapviewer.interfaces.TemplatedTileSource;
/**
* Handles templated TMS Tile Source. Templated means, that some patterns within
* URL gets substituted.
*
* Supported parameters
* {zoom} - substituted with zoom level
* {z} - as above
* {NUMBER-zoom} - substituted with result of equation "NUMBER - zoom",
* eg. {20-zoom} for zoom level 15 will result in 5 in this place
* {zoom+number} - substituted with result of equation "zoom + number",
* eg. {zoom+5} for zoom level 15 will result in 20.
* {x} - substituted with X tile number
* {y} - substituted with Y tile number
* {!y} - substituted with Yahoo Y tile number
* {-y} - substituted with reversed Y tile number
* {switch:VAL_A,VAL_B,VAL_C,...} - substituted with one of VAL_A, VAL_B, VAL_C. Usually
* used to specify many tile servers
* {header:(HEADER_NAME,HEADER_VALUE)} - sets the headers to be sent to tile server
*/
public class TemplatedTMSTileSource extends TMSTileSource implements TemplatedTileSource {
private Random rand;
private String[] randomParts;
private final Map headers = new HashMap<>();
private static final String COOKIE_HEADER = "Cookie";
private static final String PATTERN_ZOOM = "\\{(?:(\\d+)-)?z(?:oom)?([+-]\\d+)?\\}";
private static final String PATTERN_X = "\\{x\\}";
private static final String PATTERN_Y = "\\{y\\}";
private static final String PATTERN_Y_YAHOO = "\\{!y\\}";
private static final String PATTERN_NEG_Y = "\\{-y\\}";
private static final String PATTERN_SWITCH = "\\{switch:([^}]+)\\}";
private static final String PATTERN_HEADER = "\\{header\\(([^,]+),([^}]+)\\)\\}";
private static final String[] ALL_PATTERNS = {
PATTERN_HEADER, PATTERN_ZOOM, PATTERN_X, PATTERN_Y, PATTERN_Y_YAHOO, PATTERN_NEG_Y,
PATTERN_SWITCH
};
/**
* Creates Templated TMS Tile Source based on ImageryInfo
* @param info imagery info
*/
public TemplatedTMSTileSource(TileSourceInfo info) {
super(info);
if (info.getCookies() != null) {
headers.put(COOKIE_HEADER, info.getCookies());
}
handleTemplate();
}
private void handleTemplate() {
// Capturing group pattern on switch values
Matcher m = Pattern.compile(".*"+PATTERN_SWITCH+".*").matcher(baseUrl);
if (m.matches()) {
rand = new Random();
randomParts = m.group(1).split(",");
}
Pattern pattern = Pattern.compile(PATTERN_HEADER);
StringBuffer output = new StringBuffer();
Matcher matcher = pattern.matcher(baseUrl);
while (matcher.find()) {
headers.put(matcher.group(1), matcher.group(2));
matcher.appendReplacement(output, "");
}
matcher.appendTail(output);
baseUrl = output.toString();
}
@Override
public Map getHeaders() {
return headers;
}
@Override
public String getTileUrl(int zoom, int tilex, int tiley) {
int finalZoom = zoom;
Matcher m = Pattern.compile(".*"+PATTERN_ZOOM+".*").matcher(this.baseUrl);
if (m.matches()) {
if (m.group(1) != null) {
finalZoom = Integer.parseInt(m.group(1))-zoom;
}
if (m.group(2) != null) {
String ofs = m.group(2);
if (ofs.startsWith("+"))
ofs = ofs.substring(1);
finalZoom += Integer.parseInt(ofs);
}
}
String r = this.baseUrl
.replaceAll(PATTERN_ZOOM, Integer.toString(finalZoom))
.replaceAll(PATTERN_X, Integer.toString(tilex))
.replaceAll(PATTERN_Y, Integer.toString(tiley))
.replaceAll(PATTERN_Y_YAHOO, Integer.toString((int) Math.pow(2, zoom-1)-1-tiley))
.replaceAll(PATTERN_NEG_Y, Integer.toString((int) Math.pow(2, zoom)-1-tiley));
if (rand != null) {
r = r.replaceAll(PATTERN_SWITCH, randomParts[rand.nextInt(randomParts.length)]);
}
return r;
}
/**
* Checks if url is acceptable by this Tile Source
* @param url URL to check
*/
public static void checkUrl(String url) {
assert url != null && !"".equals(url) : "URL cannot be null or empty";
Matcher m = Pattern.compile("\\{[^}]*\\}").matcher(url);
while (m.find()) {
boolean isSupportedPattern = false;
for (String pattern : ALL_PATTERNS) {
if (m.group().matches(pattern)) {
isSupportedPattern = true;
break;
}
}
if (!isSupportedPattern) {
throw new IllegalArgumentException(
m.group() + " is not a valid TMS argument. Please check this server URL:\n" + url);
}
}
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/BingAerialTileSource.java 0000644 0000000 0000000 00000031666 12641052742 030726 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.tilesources;
import java.awt.Image;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.regex.Pattern;
import javax.imageio.ImageIO;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import org.openstreetmap.gui.jmapviewer.Coordinate;
import org.openstreetmap.gui.jmapviewer.JMapViewer;
import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
public class BingAerialTileSource extends AbstractTMSTileSource {
private static final String API_KEY = "Arzdiw4nlOJzRwOz__qailc8NiR31Tt51dN2D7cm57NrnceZnCpgOkmJhNpGoppU";
private static volatile Future> attributions; // volatile is required for getAttribution(), see below.
private static String imageUrlTemplate;
private static Integer imageryZoomMax;
private static String[] subdomains;
private static final Pattern subdomainPattern = Pattern.compile("\\{subdomain\\}");
private static final Pattern quadkeyPattern = Pattern.compile("\\{quadkey\\}");
private static final Pattern culturePattern = Pattern.compile("\\{culture\\}");
private String brandLogoUri;
/**
* Constructs a new {@code BingAerialTileSource}.
*/
public BingAerialTileSource() {
super(new TileSourceInfo("Bing", null, null));
}
/**
* Constructs a new {@code BingAerialTileSource}.
* @param info imagery info
*/
public BingAerialTileSource(TileSourceInfo info) {
super(info);
}
protected static class Attribution {
private String attribution;
private int minZoom;
private int maxZoom;
private Coordinate min;
private Coordinate max;
}
@Override
public String getTileUrl(int zoom, int tilex, int tiley) throws IOException {
// make sure that attribution is loaded. otherwise subdomains is null.
if (getAttribution() == null)
throw new IOException("Attribution is not loaded yet");
int t = (zoom + tilex + tiley) % subdomains.length;
String subdomain = subdomains[t];
String url = imageUrlTemplate;
url = subdomainPattern.matcher(url).replaceAll(subdomain);
url = quadkeyPattern.matcher(url).replaceAll(computeQuadTree(zoom, tilex, tiley));
return url;
}
protected URL getAttributionUrl() throws MalformedURLException {
return new URL("https://dev.virtualearth.net/REST/v1/Imagery/Metadata/Aerial?include=ImageryProviders&output=xml&key="
+ API_KEY);
}
protected List parseAttributionText(InputSource xml) throws IOException {
try {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(xml);
XPathFactory xPathFactory = XPathFactory.newInstance();
XPath xpath = xPathFactory.newXPath();
imageUrlTemplate = xpath.compile("//ImageryMetadata/ImageUrl/text()").evaluate(document);
imageUrlTemplate = imageUrlTemplate.replace(
"http://ecn.{subdomain}.tiles.virtualearth.net/",
"https://ecn.{subdomain}.tiles.virtualearth.net/");
imageUrlTemplate = culturePattern.matcher(imageUrlTemplate).replaceAll(Locale.getDefault().toString());
imageryZoomMax = Integer.valueOf(xpath.compile("//ImageryMetadata/ZoomMax/text()").evaluate(document));
NodeList subdomainTxt = (NodeList) xpath.compile("//ImageryMetadata/ImageUrlSubdomains/string/text()")
.evaluate(document, XPathConstants.NODESET);
subdomains = new String[subdomainTxt.getLength()];
for (int i = 0; i < subdomainTxt.getLength(); i++) {
subdomains[i] = subdomainTxt.item(i).getNodeValue();
}
brandLogoUri = xpath.compile("/Response/BrandLogoUri/text()").evaluate(document);
XPathExpression attributionXpath = xpath.compile("Attribution/text()");
XPathExpression coverageAreaXpath = xpath.compile("CoverageArea");
XPathExpression zoomMinXpath = xpath.compile("ZoomMin/text()");
XPathExpression zoomMaxXpath = xpath.compile("ZoomMax/text()");
XPathExpression southLatXpath = xpath.compile("BoundingBox/SouthLatitude/text()");
XPathExpression westLonXpath = xpath.compile("BoundingBox/WestLongitude/text()");
XPathExpression northLatXpath = xpath.compile("BoundingBox/NorthLatitude/text()");
XPathExpression eastLonXpath = xpath.compile("BoundingBox/EastLongitude/text()");
NodeList imageryProviderNodes = (NodeList) xpath.compile("//ImageryMetadata/ImageryProvider")
.evaluate(document, XPathConstants.NODESET);
List attributions = new ArrayList<>(imageryProviderNodes.getLength());
for (int i = 0; i < imageryProviderNodes.getLength(); i++) {
Node providerNode = imageryProviderNodes.item(i);
String attribution = attributionXpath.evaluate(providerNode);
NodeList coverageAreaNodes = (NodeList) coverageAreaXpath.evaluate(providerNode, XPathConstants.NODESET);
for (int j = 0; j < coverageAreaNodes.getLength(); j++) {
Node areaNode = coverageAreaNodes.item(j);
Attribution attr = new Attribution();
attr.attribution = attribution;
attr.maxZoom = Integer.parseInt(zoomMaxXpath.evaluate(areaNode));
attr.minZoom = Integer.parseInt(zoomMinXpath.evaluate(areaNode));
Double southLat = Double.valueOf(southLatXpath.evaluate(areaNode));
Double northLat = Double.valueOf(northLatXpath.evaluate(areaNode));
Double westLon = Double.valueOf(westLonXpath.evaluate(areaNode));
Double eastLon = Double.valueOf(eastLonXpath.evaluate(areaNode));
attr.min = new Coordinate(southLat, westLon);
attr.max = new Coordinate(northLat, eastLon);
attributions.add(attr);
}
}
return attributions;
} catch (SAXException e) {
System.err.println("Could not parse Bing aerials attribution metadata.");
e.printStackTrace();
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (XPathExpressionException e) {
e.printStackTrace();
}
return null;
}
@Override
public int getMaxZoom() {
if (imageryZoomMax != null)
return imageryZoomMax;
else
return 22;
}
@Override
public boolean requiresAttribution() {
return true;
}
@Override
public String getAttributionLinkURL() {
//return "http://bing.com/maps"
// FIXME: I've set attributionLinkURL temporarily to ToU URL to comply with bing ToU
// (the requirement is that we have such a link at the bottom of the window)
return "http://go.microsoft.com/?linkid=9710837";
}
@Override
public Image getAttributionImage() {
try {
final InputStream imageResource = JMapViewer.class.getResourceAsStream("images/bing_maps.png");
if (imageResource != null) {
return ImageIO.read(imageResource);
} else {
// Some Linux distributions (like Debian) will remove Bing logo from sources, so get it at runtime
for (int i = 0; i < 5 && getAttribution() == null; i++) {
// Makes sure attribution is loaded
if (JMapViewer.debug) {
System.out.println("Bing attribution attempt " + (i+1));
}
}
if (brandLogoUri != null && !brandLogoUri.isEmpty()) {
System.out.println("Reading Bing logo from "+brandLogoUri);
return ImageIO.read(new URL(brandLogoUri));
}
}
} catch (IOException e) {
System.err.println("Error while retrieving Bing logo: "+e.getMessage());
}
return null;
}
@Override
public String getAttributionImageURL() {
return "http://opengeodata.org/microsoft-imagery-details";
}
@Override
public String getTermsOfUseText() {
return null;
}
@Override
public String getTermsOfUseURL() {
return "http://opengeodata.org/microsoft-imagery-details";
}
protected Callable> getAttributionLoaderCallable() {
return new Callable>() {
@Override
public List call() throws Exception {
int waitTimeSec = 1;
while (true) {
try {
InputSource xml = new InputSource(getAttributionUrl().openStream());
List r = parseAttributionText(xml);
System.out.println("Successfully loaded Bing attribution data.");
return r;
} catch (IOException ex) {
System.err.println("Could not connect to Bing API. Will retry in " + waitTimeSec + " seconds.");
Thread.sleep(waitTimeSec * 1000L);
waitTimeSec *= 2;
}
}
}
};
}
protected List getAttribution() {
if (attributions == null) {
// see http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
synchronized (BingAerialTileSource.class) {
if (attributions == null) {
final FutureTask> loader = new FutureTask<>(getAttributionLoaderCallable());
new Thread(loader, "bing-attribution-loader").start();
attributions = loader;
}
}
}
try {
return attributions.get(0, TimeUnit.MILLISECONDS);
} catch (TimeoutException ex) {
System.err.println("Bing: attribution data is not yet loaded.");
} catch (ExecutionException ex) {
throw new RuntimeException(ex.getCause());
} catch (InterruptedException ign) {
System.err.println("InterruptedException: " + ign.getMessage());
}
return null;
}
@Override
public String getAttributionText(int zoom, ICoordinate topLeft, ICoordinate botRight) {
try {
final List data = getAttribution();
if (data == null)
return "Error loading Bing attribution data";
StringBuilder a = new StringBuilder();
for (Attribution attr : data) {
if (zoom <= attr.maxZoom && zoom >= attr.minZoom) {
if (topLeft.getLon() < attr.max.getLon() && botRight.getLon() > attr.min.getLon()
&& topLeft.getLat() > attr.min.getLat() && botRight.getLat() < attr.max.getLat()) {
a.append(attr.attribution);
a.append(' ');
}
}
}
return a.toString();
} catch (Exception e) {
e.printStackTrace();
}
return "Error loading Bing attribution data";
}
private static String computeQuadTree(int zoom, int tilex, int tiley) {
StringBuilder k = new StringBuilder();
for (int i = zoom; i > 0; i--) {
char digit = 48;
int mask = 1 << (i - 1);
if ((tilex & mask) != 0) {
digit += 1;
}
if ((tiley & mask) != 0) {
digit += 2;
}
k.append(digit);
}
return k.toString();
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/MapQuestOpenAerialTileSource.java 0000644 0000000 0000000 00000001462 12566160406 032422 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.tilesources;
import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
public class MapQuestOpenAerialTileSource extends AbstractMapQuestTileSource {
private static final String PATTERN = "http://oatile%d.mqcdn.com/tiles/1.0.0/sat";
public MapQuestOpenAerialTileSource() {
super("MapQuest Open Aerial", PATTERN, "mapquest-oa");
}
@Override
public String getAttributionText(int zoom, ICoordinate topLeft, ICoordinate botRight) {
return "Portions Courtesy NASA/JPL-Caltech and U.S. Depart. of Agriculture, Farm Service Agency - "+MAPQUEST_ATTRIBUTION;
}
@Override
public String getAttributionLinkURL() {
return MAPQUEST_WEBSITE;
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/OsmTileSource.java 0000644 0000000 0000000 00000003333 12641052742 027455 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.tilesources;
/**
* OSM Tile source.
*/
public class OsmTileSource {
/**
* The default "Mapnik" OSM tile source.
*/
public static class Mapnik extends AbstractOsmTileSource {
private static final String PATTERN = "https://%s.tile.openstreetmap.org";
private static final String[] SERVER = {"a", "b", "c"};
private int serverNum;
/**
* Constructs a new {@code "Mapnik"} tile source.
*/
public Mapnik() {
super("Mapnik", PATTERN, "MAPNIK");
}
@Override
public String getBaseUrl() {
String url = String.format(this.baseUrl, new Object[] {SERVER[serverNum]});
serverNum = (serverNum + 1) % SERVER.length;
return url;
}
}
/**
* The "Cycle Map" OSM tile source.
*/
public static class CycleMap extends AbstractOsmTileSource {
private static final String PATTERN = "http://%s.tile.opencyclemap.org/cycle";
private static final String[] SERVER = {"a", "b", "c"};
private int serverNum;
/**
* Constructs a new {@code CycleMap} tile source.
*/
public CycleMap() {
super("Cyclemap", PATTERN, "opencyclemap");
}
@Override
public String getBaseUrl() {
String url = String.format(this.baseUrl, new Object[] {SERVER[serverNum]});
serverNum = (serverNum + 1) % SERVER.length;
return url;
}
@Override
public int getMaxZoom() {
return 18;
}
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/AbstractTileSource.java 0000644 0000000 0000000 00000004657 12566160376 030505 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.tilesources;
import java.awt.Image;
import java.util.List;
import java.util.Map;
import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
public abstract class AbstractTileSource implements TileSource {
protected String attributionText;
protected String attributionLinkURL;
protected Image attributionImage;
protected String attributionImageURL;
protected String termsOfUseText;
protected String termsOfUseURL;
@Override
public boolean requiresAttribution() {
return attributionText != null || attributionImage != null || termsOfUseText != null || termsOfUseURL != null;
}
@Override
public String getAttributionText(int zoom, ICoordinate topLeft, ICoordinate botRight) {
return attributionText;
}
@Override
public String getAttributionLinkURL() {
return attributionLinkURL;
}
@Override
public Image getAttributionImage() {
return attributionImage;
}
@Override
public String getAttributionImageURL() {
return attributionImageURL;
}
@Override
public String getTermsOfUseText() {
return termsOfUseText;
}
@Override
public String getTermsOfUseURL() {
return termsOfUseURL;
}
public void setAttributionText(String attributionText) {
this.attributionText = attributionText;
}
public void setAttributionLinkURL(String attributionLinkURL) {
this.attributionLinkURL = attributionLinkURL;
}
public void setAttributionImage(Image attributionImage) {
this.attributionImage = attributionImage;
}
public void setAttributionImageURL(String attributionImageURL) {
this.attributionImageURL = attributionImageURL;
}
public void setTermsOfUseText(String termsOfUseText) {
this.termsOfUseText = termsOfUseText;
}
public void setTermsOfUseURL(String termsOfUseURL) {
this.termsOfUseURL = termsOfUseURL;
}
@Override
public boolean isNoTileAtZoom(Map> headers, int statusCode, byte[] content) {
// default handler - when HTTP 404 is returned, then treat this situation as no tile at this zoom level
return statusCode == 404;
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/tilesources/AbstractOsmTileSource.java 0000644 0000000 0000000 00000003502 12641052742 031137 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.tilesources;
import java.awt.Image;
import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
/**
* Abstract class for OSM Tile sources
*/
public abstract class AbstractOsmTileSource extends AbstractTMSTileSource {
/**
* The OSM attribution. Must be always in line with
* https://www.openstreetmap.org/copyright/en
*/
public static final String DEFAULT_OSM_ATTRIBUTION = "\u00a9 OpenStreetMap contributors";
/**
* Constructs a new OSM tile source
* @param name Source name as displayed in GUI
* @param baseUrl Source URL
* @param id unique id for the tile source; contains only characters that
* are safe for file names; can be null
*/
public AbstractOsmTileSource(String name, String baseUrl, String id) {
super(new TileSourceInfo(name, baseUrl, id));
}
@Override
public int getMaxZoom() {
return 19;
}
@Override
public boolean requiresAttribution() {
return true;
}
@Override
public String getAttributionText(int zoom, ICoordinate topLeft, ICoordinate botRight) {
return DEFAULT_OSM_ATTRIBUTION;
}
@Override
public String getAttributionLinkURL() {
return "https://openstreetmap.org/";
}
@Override
public Image getAttributionImage() {
return null;
}
@Override
public String getAttributionImageURL() {
return null;
}
@Override
public String getTermsOfUseText() {
return null;
}
@Override
public String getTermsOfUseURL() {
return "https://www.openstreetmap.org/copyright";
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/FeatureAdapter.java 0000644 0000000 0000000 00000005534 12566160376 025271 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import java.awt.Desktop;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.text.MessageFormat;
import java.util.logging.Logger;
public final class FeatureAdapter {
private static BrowserAdapter browserAdapter = new DefaultBrowserAdapter();
private static TranslationAdapter translationAdapter = new DefaultTranslationAdapter();
private static LoggingAdapter loggingAdapter = new DefaultLoggingAdapter();
private FeatureAdapter() {
// private constructor for utility classes
}
public interface BrowserAdapter {
void openLink(String url);
}
public interface TranslationAdapter {
String tr(String text, Object... objects);
// TODO: more i18n functions
}
public interface LoggingAdapter {
Logger getLogger(String name);
}
public static void registerBrowserAdapter(BrowserAdapter browserAdapter) {
FeatureAdapter.browserAdapter = browserAdapter;
}
public static void registerTranslationAdapter(TranslationAdapter translationAdapter) {
FeatureAdapter.translationAdapter = translationAdapter;
}
public static void registerLoggingAdapter(LoggingAdapter loggingAdapter) {
FeatureAdapter.loggingAdapter = loggingAdapter;
}
public static void openLink(String url) {
browserAdapter.openLink(url);
}
public static String tr(String text, Object... objects) {
return translationAdapter.tr(text, objects);
}
public static Logger getLogger(String name) {
return loggingAdapter.getLogger(name);
}
public static class DefaultBrowserAdapter implements BrowserAdapter {
@Override
public void openLink(String url) {
if (Desktop.isDesktopSupported() && Desktop.getDesktop().isSupported(Desktop.Action.BROWSE)) {
try {
Desktop.getDesktop().browse(new URI(url));
} catch (IOException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
}
} else {
System.err.println(tr("Opening link not supported on current platform (''{0}'')", url));
}
}
}
public static class DefaultTranslationAdapter implements TranslationAdapter {
@Override
public String tr(String text, Object... objects) {
return MessageFormat.format(text, objects);
}
}
public static class DefaultLoggingAdapter implements LoggingAdapter {
@Override
public Logger getLogger(String name) {
return Logger.getLogger(name);
}
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/MapRectangleImpl.java 0000644 0000000 0000000 00000005222 12566160376 025553 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Stroke;
import org.openstreetmap.gui.jmapviewer.interfaces.MapRectangle;
public class MapRectangleImpl extends MapObjectImpl implements MapRectangle {
private Coordinate topLeft;
private Coordinate bottomRight;
public MapRectangleImpl(Coordinate topLeft, Coordinate bottomRight) {
this(null, null, topLeft, bottomRight);
}
public MapRectangleImpl(String name, Coordinate topLeft, Coordinate bottomRight) {
this(null, name, topLeft, bottomRight);
}
public MapRectangleImpl(Layer layer, Coordinate topLeft, Coordinate bottomRight) {
this(layer, null, topLeft, bottomRight);
}
public MapRectangleImpl(Layer layer, String name, Coordinate topLeft, Coordinate bottomRight) {
this(layer, name, topLeft, bottomRight, getDefaultStyle());
}
public MapRectangleImpl(Layer layer, String name, Coordinate topLeft, Coordinate bottomRight, Style style) {
super(layer, name, style);
this.topLeft = topLeft;
this.bottomRight = bottomRight;
}
@Override
public Coordinate getTopLeft() {
return topLeft;
}
@Override
public Coordinate getBottomRight() {
return bottomRight;
}
@Override
public void paint(Graphics g, Point topLeft, Point bottomRight) {
// Prepare graphics
Color oldColor = g.getColor();
g.setColor(getColor());
Stroke oldStroke = null;
if (g instanceof Graphics2D) {
Graphics2D g2 = (Graphics2D) g;
oldStroke = g2.getStroke();
g2.setStroke(getStroke());
}
// Draw
g.drawRect(topLeft.x, topLeft.y, bottomRight.x - topLeft.x, bottomRight.y - topLeft.y);
// Restore graphics
g.setColor(oldColor);
if (g instanceof Graphics2D) {
((Graphics2D) g).setStroke(oldStroke);
}
int width = bottomRight.x-topLeft.x;
int height = bottomRight.y-topLeft.y;
Point p = new Point(topLeft.x+(width/2), topLeft.y+(height/2));
if (getLayer() == null || getLayer().isVisibleTexts()) paintText(g, p);
}
public static Style getDefaultStyle() {
return new Style(Color.BLUE, null, new BasicStroke(2), getDefaultFont());
}
@Override
public String toString() {
return "MapRectangle from " + getTopLeft() + " to " + getBottomRight();
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/ 0000755 0000000 0000000 00000000000 12641052742 023635 5 ustar root root jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/CachedTileLoader.java 0000644 0000000 0000000 00000000440 12566160406 027615 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
/**
* Interface that allow cleaning the tile cache without specifying exact type of loader
*/
public interface CachedTileLoader {
void clearCache(TileSource source);
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/ICoordinate.java 0000644 0000000 0000000 00000000377 12566160406 026712 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
public interface ICoordinate {
double getLat();
void setLat(double lat);
double getLon();
void setLon(double lon);
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/MapObject.java 0000644 0000000 0000000 00000001114 12566160406 026344 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import java.awt.Color;
import java.awt.Font;
import java.awt.Stroke;
import org.openstreetmap.gui.jmapviewer.Layer;
import org.openstreetmap.gui.jmapviewer.Style;
public interface MapObject {
Layer getLayer();
void setLayer(Layer layer);
Style getStyle();
Style getStyleAssigned();
Color getColor();
Color getBackColor();
Stroke getStroke();
Font getFont();
String getName();
boolean isVisible();
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/MapMarker.java 0000644 0000000 0000000 00000002637 12641052742 026367 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import java.awt.Graphics;
import java.awt.Point;
import org.openstreetmap.gui.jmapviewer.Coordinate;
import org.openstreetmap.gui.jmapviewer.JMapViewer;
/**
* Interface to be implemented by all one dimensional elements that can be displayed on the map.
*
* @author Jan Peter Stotz
* @see JMapViewer#addMapMarker(MapMarker)
* @see JMapViewer#getMapMarkerList()
*/
public interface MapMarker extends MapObject, ICoordinate {
enum STYLE {
FIXED,
VARIABLE
}
/**
* @return Latitude and Longitude of the map marker position
*/
Coordinate getCoordinate();
/**
* @return Latitude of the map marker position
*/
@Override
double getLat();
/**
* @return Longitude of the map marker position
*/
@Override
double getLon();
/**
* @return Radius of the map marker position
*/
double getRadius();
/**
* @return Style of the map marker
*/
STYLE getMarkerStyle();
/**
* Paints the map marker on the map. The position specifies the
* coordinates within g
*
* @param g graphics
* @param position coordinates
* @param radius radius
*/
void paint(Graphics g, Point position, int radius);
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/JMapViewerEventListener.java 0000644 0000000 0000000 00000000720 12566160406 031223 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import java.util.EventListener;
import org.openstreetmap.gui.jmapviewer.events.JMVCommandEvent;
/**
* Must be implemented for processing commands while user
* interacts with map viewer.
*
* @author Jason Huntley
*
*/
public interface JMapViewerEventListener extends EventListener {
void processCommand(JMVCommandEvent command);
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/TileLoaderListener.java 0000644 0000000 0000000 00000001052 12566160406 030233 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import org.openstreetmap.gui.jmapviewer.Tile;
public interface TileLoaderListener {
/**
* Will be called if a new {@link Tile} has been loaded successfully.
* Loaded can mean downloaded or loaded from file cache.
*
* @param tile The tile
* @param success {@code true} if the tile has been loaded successfully, {@code false} otherwise
*/
void tileLoadingFinished(Tile tile, boolean success);
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/TileClearController.java 0000644 0000000 0000000 00000000533 12566160406 030414 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import java.io.File;
public interface TileClearController {
void initClearDir(File dir);
void initClearFiles(File[] files);
boolean cancel();
void fileDeleted(File file);
void clearFinished();
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/Attributed.java 0000644 0000000 0000000 00000003132 12566160406 026611 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import java.awt.Image;
public interface Attributed {
/**
* @return True if the tile source requires attribution in text or image form.
*/
boolean requiresAttribution();
/**
* @param zoom The optional zoom level for the view.
* @param botRight The bottom right of the bounding box for attribution.
* @param topLeft The top left of the bounding box for attribution.
* @return Attribution text for the image source.
*/
String getAttributionText(int zoom, ICoordinate topLeft, ICoordinate botRight);
/**
* @return The URL to open when the user clicks the attribution text.
*/
String getAttributionLinkURL();
/**
* @return The URL for the attribution image. Null if no image should be displayed.
*/
Image getAttributionImage();
/**
* @return The URL to open when the user clicks the attribution image.
* When return value is null, the image is still displayed (provided getAttributionImage()
* returns a value other than null), but the image does not link to a website.
*/
String getAttributionImageURL();
/**
* @return The attribution "Terms of Use" text.
* In case it returns null, but getTermsOfUseURL() is not null, a default
* terms of use text is used.
*/
String getTermsOfUseText();
/**
* @return The URL to open when the user clicks the attribution "Terms of Use" text.
*/
String getTermsOfUseURL();
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/TileCache.java 0000644 0000000 0000000 00000003104 12641052742 026317 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import org.openstreetmap.gui.jmapviewer.JMapViewer;
import org.openstreetmap.gui.jmapviewer.Tile;
/**
* Implement this interface for creating your custom tile cache for
* {@link JMapViewer}.
*
* @author Jan Peter Stotz
*/
public interface TileCache {
/**
* Retrieves a tile from the cache if present, otherwise null
* will be returned.
*
* @param source
* the tile source
* @param x
* tile number on the x axis of the tile to be retrieved
* @param y
* tile number on the y axis of the tile to be retrieved
* @param z
* zoom level of the tile to be retrieved
* @return the requested tile or null if the tile is not
* present in the cache
*/
Tile getTile(TileSource source, int x, int y, int z);
/**
* Adds a tile to the cache. How long after adding a tile can be retrieved
* via {@link #getTile(TileSource, int, int, int)} is unspecified and depends on the
* implementation.
*
* @param tile the tile to be added
*/
void addTile(Tile tile);
/**
* @return the number of tiles hold by the cache
*/
int getTileCount();
/**
* Clears the cache deleting all tiles from memory.
*/
void clear();
/**
* Size of the cache.
* @return maximum number of tiles in cache
*/
int getCacheSize();
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/TileLoader.java 0000644 0000000 0000000 00000001611 12604423574 026527 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import org.openstreetmap.gui.jmapviewer.Tile;
/**
* Interface for implementing a tile loader. Tiles are usually loaded via HTTP
* or from a file.
*
* @author Jan Peter Stotz
*/
public interface TileLoader {
/**
* A typical implementation of this function should create and return a
* new {@link TileJob} instance that performs the load action.
*
* @param tile the tile to be loaded
* @return {@link TileJob} implementation that performs the desired load
* action.
*/
TileJob createTileLoaderJob(Tile tile);
/**
* cancels all outstanding tasks in the queue. This should rollback the state of the tiles in the queue
* to loading = false / loaded = false
*/
void cancelOutstandingTasks();
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/TileSource.java 0000644 0000000 0000000 00000014064 12604423574 026567 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import java.awt.Point;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import org.openstreetmap.gui.jmapviewer.JMapViewer;
import org.openstreetmap.gui.jmapviewer.Tile;
import org.openstreetmap.gui.jmapviewer.TileXY;
/**
*
* @author Jan Peter Stotz
*/
public interface TileSource extends Attributed {
/**
* Specifies the maximum zoom value. The number of zoom levels is [0..
* {@link #getMaxZoom()}].
*
* @return maximum zoom value that has to be smaller or equal to
* {@link JMapViewer#MAX_ZOOM}
*/
int getMaxZoom();
/**
* Specifies the minimum zoom value. This value is usually 0.
* Only for maps that cover a certain region up to a limited zoom level
* this method should return a value different than 0.
*
* @return minimum zoom value - usually 0
*/
int getMinZoom();
/**
* A tile layer name as displayed to the user.
*
* @return Name of the tile layer
*/
String getName();
/**
* A unique id for this tile source.
*
* Unlike the name it has to be unique and has to consist only of characters
* valid for filenames.
*
* @return the id
*/
String getId();
/**
* Constructs the tile url.
*
* @param zoom zoom level
* @param tilex X coordinate
* @param tiley Y coordinate
* @return fully qualified url for downloading the specified tile image
* @throws IOException if any I/O error occurs
*/
String getTileUrl(int zoom, int tilex, int tiley) throws IOException;
/**
* Creates tile identifier that is unique among all tile sources, but the same tile will always
* get the same identifier. Used for creation of cache key.
*
* @param zoom zoom level
* @param tilex X coordinate
* @param tiley Y coordinate
* @return tile identifier
*/
String getTileId(int zoom, int tilex, int tiley);
/**
* Specifies how large each tile is.
* @return The size of a single tile in pixels. -1 if default size should be used
*/
int getTileSize();
/**
* @return default tile size, for this tile source
* TODO: @since
*/
int getDefaultTileSize();
/**
* Gets the distance using Spherical law of cosines.
* @param la1 latitude of first point
* @param lo1 longitude of first point
* @param la2 latitude of second point
* @param lo2 longitude of second point
* @return the distance betwen first and second point, in m.
*/
double getDistance(double la1, double lo1, double la2, double lo2);
/**
* @param lon longitude
* @param lat latitude
* @param zoom zoom level
* @return transforms longitude and latitude to pixel space (as if all tiles at specified zoom level where joined)
*/
Point latLonToXY(double lat, double lon, int zoom);
/**
* @param point point
* @param zoom zoom level
* @return transforms longitude and latitude to pixel space (as if all tiles at specified zoom level where joined)
*/
Point latLonToXY(ICoordinate point, int zoom);
/**
* @param point point
* @param zoom zoom level
* @return WGS84 Coordinates of given point
*/
ICoordinate xyToLatLon(Point point, int zoom);
/**
*
* @param x X coordinate
* @param y Y coordinate
* @param zoom zoom level
* @return WGS84 Coordinates of given point
*/
ICoordinate xyToLatLon(int x, int y, int zoom);
/**
* @param lon longitude
* @param lat latitude
* @param zoom zoom level
* @return x and y tile indices
*/
TileXY latLonToTileXY(double lat, double lon, int zoom);
/**
*
* @param point point
* @param zoom zoom level
* @return x and y tile indices
*/
TileXY latLonToTileXY(ICoordinate point, int zoom);
/**
* @param xy X/Y coordinates
* @param zoom zoom level
* @return WGS84 coordinates of given tile
*/
ICoordinate tileXYToLatLon(TileXY xy, int zoom);
/**
*
* @param tile Tile
* @return WGS84 coordinates of given tile
*/
ICoordinate tileXYToLatLon(Tile tile);
/**
*
* @param x X coordinate
* @param y Y coordinate
* @param zoom zoom level
* @return WGS84 coordinates of given tile
*/
ICoordinate tileXYToLatLon(int x, int y, int zoom);
/**
* @param zoom zoom level
* @return maximum X index of tile for specified zoom level
*/
int getTileXMax(int zoom);
/**
*
* @param zoom zoom level
* @return minimum X index of tile for specified zoom level
*/
int getTileXMin(int zoom);
/**
*
* @param zoom zoom level
* @return maximum Y index of tile for specified zoom level
*/
int getTileYMax(int zoom);
/**
* @param zoom zoom level
* @return minimum Y index of tile for specified zoom level
*/
int getTileYMin(int zoom);
/**
* Determines, if the returned data from TileSource represent "no tile at this zoom level" situation. Detection
* algorithms differ per TileSource, so each TileSource should implement each own specific way.
*
* @param headers HTTP headers from response from TileSource server
* @param statusCode HTTP status code
* @param content byte array representing the data returned from the server
* @return true, if "no tile at this zoom level" situation detected
*/
boolean isNoTileAtZoom(Map> headers, int statusCode, byte[] content);
/**
* Extracts metadata about the tile based on HTTP headers
*
* @param headers HTTP headers from Tile Source server
* @return tile metadata
*/
Map getMetadata(Map> headers);
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/TileJob.java 0000644 0000000 0000000 00000001373 12566160406 026037 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import org.openstreetmap.gui.jmapviewer.Tile;
/**
* Interface for implementing a tile loading job. Tiles are usually loaded via HTTP
* or from a file.
*
* @author Dirk Stöcker
*/
public interface TileJob extends Runnable {
/**
* Function to return the tile associated with the job
*
* @return {@link Tile} to be handled
*/
Tile getTile();
/**
* submits download job to backend.
*/
void submit();
/**
* submits download job to backend.
* @param force true if the load should skip all the caches (local & remote)
*/
void submit(boolean force);
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/TemplatedTileSource.java 0000644 0000000 0000000 00000000654 12566160406 030426 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import java.util.Map;
/**
* Interface for template tile sources, @see TemplatedTMSTileSource
*
* @author Wiktor Niesiobędzki
* @since 1.10
*/
public interface TemplatedTileSource extends TileSource {
/**
*
* @return headers to be sent with http requests
*/
Map getHeaders();
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/MapRectangle.java 0000644 0000000 0000000 00000002237 12641052742 027046 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import java.awt.Graphics;
import java.awt.Point;
import org.openstreetmap.gui.jmapviewer.Coordinate;
import org.openstreetmap.gui.jmapviewer.JMapViewer;
/**
* Interface to be implemented by rectangles that can be displayed on the map.
*
* @author Stefan Zeller
* @see JMapViewer#addMapRectangle(MapRectangle)
* @see JMapViewer#getMapRectangleList()
*/
public interface MapRectangle extends MapObject {
/**
* @return Latitude/Longitude of top left of rectangle
*/
Coordinate getTopLeft();
/**
* @return Latitude/Longitude of bottom right of rectangle
*/
Coordinate getBottomRight();
/**
* Paints the map rectangle on the map. The topLeft and
* bottomRight are specifying the coordinates within g
*
* @param g graphics structure for painting
* @param topLeft lop left edge of painting region
* @param bottomRight bottom right edge of painting region
*/
void paint(Graphics g, Point topLeft, Point bottomRight);
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/interfaces/MapPolygon.java 0000644 0000000 0000000 00000002060 12641052742 026563 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.interfaces;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Polygon;
import java.util.List;
/**
* Interface to be implemented by polygons that can be displayed on the map.
*
* @author Vincent Privat
*/
public interface MapPolygon extends MapObject {
/**
* @return Latitude/Longitude of each point of polygon
*/
List getPoints();
/**
* Paints the map polygon on the map. The points
* are specifying the coordinates within g
*
* @param g graphics
* @param points list of points defining the polygon to draw
*/
void paint(Graphics g, List points);
/**
* Paints the map polygon on the map. The polygon
* is specifying the coordinates within g
*
* @param g graphics
* @param polygon polygon to draw
*/
void paint(Graphics g, Polygon polygon);
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/MapPolygonImpl.java 0000644 0000000 0000000 00000007011 12641052742 025263 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.Rectangle;
import java.awt.Stroke;
import java.util.Arrays;
import java.util.List;
import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
import org.openstreetmap.gui.jmapviewer.interfaces.MapPolygon;
public class MapPolygonImpl extends MapObjectImpl implements MapPolygon {
private List points;
public MapPolygonImpl(ICoordinate ... points) {
this(null, null, points);
}
public MapPolygonImpl(List points) {
this(null, null, points);
}
public MapPolygonImpl(String name, List points) {
this(null, name, points);
}
public MapPolygonImpl(String name, ICoordinate ... points) {
this(null, name, points);
}
public MapPolygonImpl(Layer layer, List points) {
this(layer, null, points);
}
public MapPolygonImpl(Layer layer, String name, List points) {
this(layer, name, points, getDefaultStyle());
}
public MapPolygonImpl(Layer layer, String name, ICoordinate ... points) {
this(layer, name, Arrays.asList(points), getDefaultStyle());
}
public MapPolygonImpl(Layer layer, String name, List points, Style style) {
super(layer, name, style);
this.points = points;
}
@Override
public List getPoints() {
return this.points;
}
@Override
public void paint(Graphics g, List points) {
Polygon polygon = new Polygon();
for (Point p : points) {
polygon.addPoint(p.x, p.y);
}
paint(g, polygon);
}
@Override
public void paint(Graphics g, Polygon polygon) {
// Prepare graphics
Color oldColor = g.getColor();
g.setColor(getColor());
Stroke oldStroke = null;
if (g instanceof Graphics2D) {
Graphics2D g2 = (Graphics2D) g;
oldStroke = g2.getStroke();
g2.setStroke(getStroke());
}
// Draw
g.drawPolygon(polygon);
if (g instanceof Graphics2D && getBackColor() != null) {
Graphics2D g2 = (Graphics2D) g;
Composite oldComposite = g2.getComposite();
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
g2.setPaint(getBackColor());
g2.fillPolygon(polygon);
g2.setComposite(oldComposite);
}
// Restore graphics
g.setColor(oldColor);
if (g instanceof Graphics2D) {
((Graphics2D) g).setStroke(oldStroke);
}
Rectangle rec = polygon.getBounds();
Point corner = rec.getLocation();
Point p = new Point(corner.x+(rec.width/2), corner.y+(rec.height/2));
if (getLayer() == null || getLayer().isVisibleTexts()) paintText(g, p);
}
public static Style getDefaultStyle() {
return new Style(Color.BLUE, new Color(100, 100, 100, 50), new BasicStroke(2), getDefaultFont());
}
@Override
public String toString() {
return "MapPolygon [points=" + points + ']';
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/checkBoxTree/ 0000755 0000000 0000000 00000000000 12641052742 024060 5 ustar root root jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/checkBoxTree/CheckBoxNodeRenderer.java 0000644 0000000 0000000 00000011116 12641052742 030706 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.checkBoxTree;
import java.awt.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.event.MouseAdapter;
import javax.swing.JTree;
import javax.swing.UIManager;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreeCellRenderer;
/**
* Renderer for checkBox Tree
*
* @author galo
*/
public class CheckBoxNodeRenderer implements TreeCellRenderer {
private final CheckBoxNodePanel panel = new CheckBoxNodePanel();
private final DefaultTreeCellRenderer defaultRenderer = new DefaultTreeCellRenderer();
private final Color selectionForeground;
private final Color selectionBackground;
private final Color textForeground;
private final Color textBackground;
/**
* Constructs a new {@code CheckBoxNodeRenderer}.
*/
public CheckBoxNodeRenderer() {
final Font fontValue = UIManager.getFont("Tree.font");
if (fontValue != null) panel.getLabel().setFont(fontValue);
final Boolean focusPainted =
(Boolean) UIManager.get("Tree.drawsFocusBorderAroundIcon");
panel.check.setFocusPainted(focusPainted != null && focusPainted);
selectionForeground = UIManager.getColor("Tree.selectionForeground");
selectionBackground = UIManager.getColor("Tree.selectionBackground");
textForeground = UIManager.getColor("Tree.textForeground");
textBackground = UIManager.getColor("Tree.textBackground");
}
protected CheckBoxNodePanel getPanel() {
return panel;
}
public void addNodeListener(MouseAdapter listener) {
panel.addMouseListener(listener);
}
// -- TreeCellRenderer methods --
@Override
public Component getTreeCellRendererComponent(final JTree tree,
final Object value, final boolean selected, final boolean expanded,
final boolean leaf, final int row, final boolean hasFocus) {
CheckBoxNodeData data = null;
if (value instanceof DefaultMutableTreeNode) {
final DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
final Object userObject = node.getUserObject();
if (userObject instanceof CheckBoxNodeData) {
data = (CheckBoxNodeData) userObject;
}
}
//final String stringValue =
// tree.convertValueToText(value, selected, expanded, leaf, row, false);
//panel.label.setText(stringValue);
panel.setSelected(Boolean.FALSE);
panel.setEnabled(tree.isEnabled());
if (selected) {
panel.setForeground(selectionForeground);
panel.setBackground(selectionBackground);
panel.getLabel().setForeground(selectionForeground);
panel.getLabel().setBackground(selectionBackground);
} else {
panel.setForeground(textForeground);
panel.setBackground(textBackground);
panel.getLabel().setForeground(textForeground);
panel.getLabel().setBackground(textBackground);
}
if (data == null) {
// not a check box node; return default cell renderer
return defaultRenderer.getTreeCellRendererComponent(tree, value,
selected, expanded, leaf, row, hasFocus);
}
//panel.label.setText(data.getText());
panel.setData(data);
panel.setSelected(data.isSelected());
return panel;
}
/*
private JPopupMenu createPopupMenu(final AbstractLayer layer) {
JMenuItem menuItem;
//Create the popup menu.
if (layer.isVisibleTexts()) menuItem = new JMenuItem("hide texts");
else menuItem = new JMenuItem("show texts");
JPopupMenu popup = new JPopupMenu();
popup.add(menuItem);
menuItem.addActionListener(new ActionListener(){
@Override
public void actionPerformed(ActionEvent arg0) {
setVisibleTexts(layer, !layer.isVisibleTexts());
}
});
return popup;
}
private void setVisibleTexts(AbstractLayer layer, boolean visible) {
layer.setVisibleTexts(visible);
if (layer instanceof LayerGroup) {
LayerGroup group = (LayerGroup) layer;
if (group.getLayers() != null)
for (AbstractLayer al : group.getLayers()) {
setVisibleTexts(al, visible);
}
}
}
*/
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/checkBoxTree/CheckBoxNodeData.java 0000644 0000000 0000000 00000002376 12641052742 030021 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.checkBoxTree;
import org.openstreetmap.gui.jmapviewer.AbstractLayer;
import org.openstreetmap.gui.jmapviewer.LayerGroup;
/**
* Node Data for checkBox Tree
*
* @author galo
*/
public class CheckBoxNodeData {
private AbstractLayer layer;
public CheckBoxNodeData(final AbstractLayer layer) {
this.layer = layer;
}
public CheckBoxNodeData(final String txt) {
this(new LayerGroup(txt));
}
public CheckBoxNodeData(final String txt, final Boolean selected) {
this(new LayerGroup(txt));
layer.setVisible(selected);
}
public Boolean isSelected() {
return layer.isVisible();
}
public void setSelected(final Boolean newValue) {
layer.setVisible(newValue);
}
public String getText() {
return layer.getName();
}
public AbstractLayer getAbstractLayer() {
return layer;
}
public void setAbstractLayer(final AbstractLayer layer) {
this.layer = layer;
}
@Override
public String toString() {
return getClass().getSimpleName() + '[' + getText() + '/' + isSelected() + ']';
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/checkBoxTree/CheckBoxTree.java 0000644 0000000 0000000 00000023211 12641052742 027230 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.checkBoxTree;
import java.awt.BorderLayout;
import java.awt.event.MouseAdapter;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import org.openstreetmap.gui.jmapviewer.AbstractLayer;
import org.openstreetmap.gui.jmapviewer.Layer;
import org.openstreetmap.gui.jmapviewer.LayerGroup;
/**
* JTree for checkBox Tree Layers
*
* @author galo
*/
public class CheckBoxTree extends JTree {
/** Serial Version UID */
private static final long serialVersionUID = 6943401106938034256L;
private final CheckBoxNodeEditor editor;
public CheckBoxTree(AbstractLayer layer) {
this(new CheckBoxNodeData(layer));
}
public CheckBoxTree(String rootName) {
this(new CheckBoxNodeData(rootName));
}
public CheckBoxTree(CheckBoxNodeData root) {
this(new DefaultMutableTreeNode(root));
}
public CheckBoxTree(DefaultMutableTreeNode node) {
super(new DefaultTreeModel(node));
final CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();
setCellRenderer(renderer);
editor = new CheckBoxNodeEditor(this);
setCellEditor(editor);
setEditable(true);
// listen for changes in the model (including check box toggles)
getModel().addTreeModelListener(new TreeModelListener() {
@Override
public void treeNodesChanged(final TreeModelEvent e) {
DefaultTreeModel model = (DefaultTreeModel) e.getSource();
Object[] nodes = e.getChildren();
DefaultMutableTreeNode node;
if (nodes == null || nodes.length == 0) {
node = node(model.getRoot());
} else {
node = node(nodes[0]);
}
nodeChanged(node);
repaint();
}
@Override
public void treeNodesInserted(final TreeModelEvent e) {
//System.out.println("nodes inserted");
}
@Override
public void treeNodesRemoved(final TreeModelEvent e) {
//System.out.println("nodes removed");
}
@Override
public void treeStructureChanged(final TreeModelEvent e) {
//System.out.println("structure changed");
}
});
}
public void addNodeListener(MouseAdapter listener) {
editor.addNodeListener(listener);
}
public static void main(final String[] args) {
final DefaultMutableTreeNode root = new DefaultMutableTreeNode(new CheckBoxNodeData("Root", Boolean.TRUE));
final DefaultMutableTreeNode accessibility =
add(root, "Accessibility", true);
add(accessibility, "Move system caret with focus/selection changes", false);
add(accessibility, "Always expand alt text for images", true);
root.add(accessibility);
final DefaultMutableTreeNode browsing =
new DefaultMutableTreeNode(new CheckBoxNodeData("Browsing", null));
add(browsing, "Notify when downloads complete", true);
add(browsing, "Disable script debugging", true);
add(browsing, "Use AutoComplete", true);
add(browsing, "Browse in a new process", false);
root.add(browsing);
final CheckBoxTree tree = new CheckBoxTree(root);
((DefaultMutableTreeNode) tree.getModel().getRoot()).add(new DefaultMutableTreeNode(new CheckBoxNodeData("gggg", null)));
((DefaultTreeModel) tree.getModel()).reload();
// listen for changes in the selection
tree.addTreeSelectionListener(new TreeSelectionListener() {
@Override
public void valueChanged(final TreeSelectionEvent e) {
//System.out.println("selection changed");
}
});
// show the tree on screen
final JFrame frame = new JFrame("CheckBox Tree");
final JScrollPane scrollPane = new JScrollPane(tree);
frame.getContentPane().add(scrollPane, BorderLayout.CENTER);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 150);
frame.setVisible(true);
}
private static Boolean childStatus(DefaultMutableTreeNode node) {
Boolean status = data(node.getChildAt(0)).isSelected();
for (int i = 1; i < node.getChildCount() && status != null; i++) {
if (!status.equals(
data(node.getChildAt(i)).isSelected()
))
return null;
}
return status;
}
private static void changeParents(DefaultMutableTreeNode node) {
if (node != null) {
DefaultMutableTreeNode parent = node(node.getParent());
if (parent != null) {
CheckBoxNodeData dataParent = data(parent);
Boolean childStatus = childStatus(parent);
if (childStatus != null && !childStatus.equals(dataParent.isSelected())) {
dataParent.setSelected(childStatus);
changeParents(parent);
}
}
}
}
private static void nodeChanged(DefaultMutableTreeNode node) {
if (node != null) {
changeParents(node);
setChildrens(node, data(node).isSelected());
}
}
private static void setChildrens(DefaultMutableTreeNode node, Boolean value) {
for (int i = 0; i < node.getChildCount(); i++) {
DefaultMutableTreeNode childNode = node(node.getChildAt(i));
if (!data(childNode).isSelected().equals(data(node).isSelected())) {
data(childNode).setSelected(data(node).isSelected());
setChildrens(childNode, value);
}
}
}
public DefaultMutableTreeNode rootNode() {
return node(getModel().getRoot());
}
public LayerGroup rootLayer() {
return (LayerGroup) rootData().getAbstractLayer();
}
public CheckBoxNodeData rootData() {
return data(rootNode());
}
private static DefaultMutableTreeNode node(Object node) {
return (DefaultMutableTreeNode) node;
}
public static CheckBoxNodeData data(DefaultMutableTreeNode node) {
return node == null ? null : (CheckBoxNodeData) node.getUserObject();
}
private static CheckBoxNodeData data(Object node) {
return data(node(node));
}
private static DefaultMutableTreeNode add(final DefaultMutableTreeNode parent, final String text, final boolean checked) {
final CheckBoxNodeData data = new CheckBoxNodeData(text, checked);
final DefaultMutableTreeNode node = new DefaultMutableTreeNode(data);
parent.add(node);
return node;
}
public static CheckBoxNodeData createNodeData(AbstractLayer layer) {
return new CheckBoxNodeData(layer);
}
public static DefaultMutableTreeNode createNode(AbstractLayer layer) {
return new DefaultMutableTreeNode(createNodeData(layer));
}
/*public DefaultMutableTreeNode addLayerGroup(LayerGroup group) {
if (group != null){
if (group.getParent() == null){
return add(rootNode(), group);
} else {
DefaultMutableTreeNode parentGroup = searchNode(group.getParent());
if(parentGroup==null) parentGroup = addLayerGroup(group.getParent());
DefaultMutableTreeNode node = add(parentGroup, group);
return node;
}
}else return null;
}*/
public Layer addLayer(String name) {
Layer layer = new Layer(name);
addLayer(layer);
return layer;
}
public DefaultMutableTreeNode addLayer(AbstractLayer layer) {
if (layer != null) {
DefaultMutableTreeNode parent;
if (layer.getParent() == null) {
rootLayer().add(layer);
parent = rootNode();
} else {
parent = searchNode(layer.getParent());
if (parent == null)
parent = addLayer(layer.getParent());
}
return add(parent, layer);
} else return null;
}
public DefaultMutableTreeNode add(DefaultMutableTreeNode parent, final AbstractLayer layer) {
layer.setVisible(data(parent).isSelected());
DefaultMutableTreeNode node = createNode(layer);
parent.add(node);
((DefaultTreeModel) getModel()).reload();
//System.out.println("Created node "+layer+" upper of "+data(parent));
return node;
}
public DefaultMutableTreeNode searchNode(AbstractLayer layer) {
return searchNode(rootNode(), layer);
}
public DefaultMutableTreeNode searchNode(DefaultMutableTreeNode node, AbstractLayer layer) {
CheckBoxNodeData data = CheckBoxTree.data(node);
if (data.getAbstractLayer() == layer) return node;
else {
DefaultMutableTreeNode found = null;
for (int i = 0; i < node.getChildCount() && found == null; i++) {
found = searchNode((DefaultMutableTreeNode) node.getChildAt(i), layer);
}
return found;
}
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/checkBoxTree/CheckBoxNodePanel.java 0000644 0000000 0000000 00000002652 12566160376 030215 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.checkBoxTree;
import java.awt.BorderLayout;
import java.awt.Insets;
import javax.swing.JCheckBox;
import javax.swing.JLabel;
import javax.swing.JPanel;
/**
* Node Panel for checkBox Tree
*
* @author galo
*/
public class CheckBoxNodePanel extends JPanel {
/** Serial Version UID */
private static final long serialVersionUID = -7236481597785619029L;
private final JLabel label = new JLabel();
private CheckBoxNodeData data;
public final JCheckBox check = new JCheckBox();
public CheckBoxNodePanel() {
this.check.setMargin(new Insets(0, 0, 0, 0));
setLayout(new BorderLayout());
add(check, BorderLayout.WEST);
add(label, BorderLayout.CENTER);
}
public void setSelected(Boolean bool) {
if (bool == null) {
check.getModel().setPressed(true);
check.getModel().setArmed(true);
} else {
check.setSelected(bool.booleanValue());
check.getModel().setArmed(false);
}
}
public CheckBoxNodeData getData() {
data.setSelected(check.isSelected());
return data;
}
public void setData(CheckBoxNodeData data) {
this.data = data;
label.setText(data.getText());
}
public JLabel getLabel() {
return label;
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/checkBoxTree/CheckBoxNodeEditor.java 0000644 0000000 0000000 00000007027 12641052742 030374 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer.checkBoxTree;
import java.awt.Component;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.EventObject;
import javax.swing.AbstractCellEditor;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeCellEditor;
import javax.swing.tree.TreePath;
/**
* Editor for checkBox Tree
*
* @author galo
*/
public class CheckBoxNodeEditor extends AbstractCellEditor implements TreeCellEditor {
/** SerialVersionUID */
private static final long serialVersionUID = -8921320784224636657L;
private final CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();
private final CheckBoxTree theTree;
public CheckBoxNodeEditor(final CheckBoxTree tree) {
theTree = tree;
}
@Override
public Object getCellEditorValue() {
final CheckBoxNodePanel panel = renderer.getPanel();
/*final CheckBoxNodeData checkBoxNode =
new CheckBoxNodeData(panel.label.getText(), panel.check.isSelected());
return checkBoxNode;
CheckBoxNodeData data = search(theTree.rootNode(), panel.label.getText());
data.setSelected(panel.check.isSelected());*/
return panel.getData();
}
/*public CheckBoxNodeData search(DefaultMutableTreeNode node, String name){
CheckBoxNodeData data = CheckBoxTree.data(node);
if(data.getText().equals(name)) return data;
else{
data = null;
for(int i=0; i aUnderline = new HashMap<>();
aUnderline.put(TextAttribute.UNDERLINE, TextAttribute.UNDERLINE_ON);
ATTR_LINK_FONT = ATTR_FONT.deriveFont(aUnderline);
}
public void initialize(Attributed source) {
this.source = source;
boolean requireAttr = source.requiresAttribution();
if (requireAttr) {
attrImage = source.getAttributionImage();
attrTermsText = source.getTermsOfUseText();
attrTermsUrl = source.getTermsOfUseURL();
if (attrTermsUrl != null && attrTermsText == null) {
attrTermsText = tr("Background Terms of Use");
}
} else {
attrImage = null;
attrTermsUrl = null;
}
}
public void paintAttribution(Graphics g, int width, int height, ICoordinate topLeft, ICoordinate bottomRight,
int zoom, ImageObserver observer) {
if (source == null || !source.requiresAttribution()) {
attrToUBounds = null;
attrImageBounds = null;
attrTextBounds = null;
return;
}
// Draw attribution
Font font = g.getFont();
g.setFont(ATTR_LINK_FONT);
// Draw terms of use text
int termsTextHeight = 0;
int termsTextY = height;
if (attrTermsText != null) {
Rectangle2D termsStringBounds = g.getFontMetrics().getStringBounds(attrTermsText, g);
int textRealHeight = (int) termsStringBounds.getHeight();
termsTextHeight = textRealHeight - 5;
int termsTextWidth = (int) termsStringBounds.getWidth();
termsTextY = height - termsTextHeight;
int x = 2;
int y = height - termsTextHeight;
attrToUBounds = new Rectangle(x, y-termsTextHeight, termsTextWidth, textRealHeight);
g.setColor(Color.black);
g.drawString(attrTermsText, x + 1, y + 1);
g.setColor(Color.white);
g.drawString(attrTermsText, x, y);
} else {
attrToUBounds = null;
}
// Draw attribution logo
if (attrImage != null) {
int x = 2;
int imgWidth = attrImage.getWidth(observer);
int imgHeight = attrImage.getHeight(observer);
int y = termsTextY - imgHeight - termsTextHeight - 5;
attrImageBounds = new Rectangle(x, y, imgWidth, imgHeight);
g.drawImage(attrImage, x, y, null);
} else {
attrImageBounds = null;
}
g.setFont(ATTR_FONT);
String attributionText = source.getAttributionText(zoom, topLeft, bottomRight);
if (attributionText != null) {
Rectangle2D stringBounds = g.getFontMetrics().getStringBounds(attributionText, g);
int textHeight = (int) stringBounds.getHeight() - 5;
int x = width - (int) stringBounds.getWidth();
int y = height - textHeight;
g.setColor(Color.black);
g.drawString(attributionText, x + 1, y + 1);
g.setColor(Color.white);
g.drawString(attributionText, x, y);
attrTextBounds = new Rectangle(x, y-textHeight, (int) stringBounds.getWidth(), (int) stringBounds.getHeight());
} else {
attrTextBounds = null;
}
g.setFont(font);
}
public boolean handleAttributionCursor(Point p) {
if (attrTextBounds != null && attrTextBounds.contains(p)) {
return true;
} else if (attrImageBounds != null && attrImageBounds.contains(p)) {
return true;
} else if (attrToUBounds != null && attrToUBounds.contains(p)) {
return true;
}
return false;
}
public boolean handleAttribution(Point p, boolean click) {
if (source == null || !source.requiresAttribution())
return false;
if (attrTextBounds != null && attrTextBounds.contains(p)) {
String attributionURL = source.getAttributionLinkURL();
if (attributionURL != null) {
if (click) {
FeatureAdapter.openLink(attributionURL);
}
return true;
}
} else if (attrImageBounds != null && attrImageBounds.contains(p)) {
String attributionImageURL = source.getAttributionImageURL();
if (attributionImageURL != null) {
if (click) {
FeatureAdapter.openLink(source.getAttributionImageURL());
}
return true;
}
} else if (attrToUBounds != null && attrToUBounds.contains(p)) {
String termsOfUseURL = source.getTermsOfUseURL();
if (termsOfUseURL != null) {
if (click) {
FeatureAdapter.openLink(termsOfUseURL);
}
return true;
}
}
return false;
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/images/ 0000755 0000000 0000000 00000000000 12447532146 022764 5 ustar root root jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/images/plus.png 0000644 0000000 0000000 00000000205 12447532144 024450 0 ustar root root ‰PNG
IHDR ü|”l LIDATxc€F†9 —p&…˜ö2ü”H,ƒÂ`‰çPÞR0þÃ#q
?ƒ>Ayç˜Á•a Xb D„Šþ œŸFuIb# IEND®B`‚ jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/images/error.png 0000644 0000000 0000000 00000006221 12447532146 024624 0 ustar root root ‰PNG
IHDR \r¨f XIDATxb¼æçñŸaD‚Q0
F¬ 8ðÿÿÿƒ#ÄÏ£`Œf|FF{ å . € Èi1¾ £`4 Ø©c" BÑ®û7ð —À J € @ € @ € @ € @ P @ € @ € @ € @ € P @ € @ € @ € @ € ð( –½3£¼ ð3»ë ß!ñ±&W! %³„à\½D»@R@EUÕûÿ§¨@¨¢ªªVm…øPÑKmÕûTÑŠ(ˆ$ÎÅ™8N ˆ¤\ ñ®“ߎcïÎx‡µ”N¼±Õï‘ü!^K›/Ïó ûî;;_Ú‘€;6
Ü$™zÒR,ð p»É¾·Ö/\ Ô (;Ú["ÀõÅXŒ <&pÛT‹Ø—‘“±ñïMö½ƒ€r[p ò < ÁZ·r8BUD\’ì(±I!S*bŸ-Å›Â[`‡˜iE8.)ö†Û
%Ê ‹ e{{K°!ìÈ¿êT˜èEó)½éV† ÿ o½JK©!LÉL`À‘_<ùÙ!êg6RqÅ5ô½ÒÆÑ®£ì i{o%¯ù¤ xò{#ÿ«† ù/tä}Ę4'ÿù‰CF#’ÉÀ #?ü·ü•W]‹ ÆN;ØGg÷1Z½€hòœ;Ñ …m™‘cë–Õ§É/bL:ÅÐÿ ãðA¶¹ËIZ—ŸtG~OþŧÉ/bã¾wšÞítö g¯eHçýž€ò©Å€ÀÈï xóšá"GþËß#¿Ø6Fì4ƒO>Jüí×Æ" ¹‹8d¤ ùÅÁØiz¾L¼×€`t9×|Zÿ´´·Œ
bkFŠhú_ò‹ˆ@*ÍÀæǼÎöâL$‡)ù°!;ò/ñ‘_Ä`Fÿ¦ûµWèì=A›%Ø¢ÈW>³D÷lmoù9Â]«F"Ì»p¾¯übLæ'f`뿈w¼ÁŽ¢4)&&∡˜‰Ê//¯¿Ê‘¾.ö#ü¸—¼Bù¬ ÿÙ²¿¥³«áŽdåwß¡ˆ¿übÀ[—nŠŽŽ73³[—'%3òGr’ß`Ä`ìÇÚ÷°]Ò$!\@^¡|NÿlÞßòc¯® Ž0Çþl `ùÊ/Æ}Qv H "1ÐÇ [ ÷\¯(þèÈï=®++Õ$ÊOöomº¾M¢¿ß@À÷”{5 ÿ‹ÞÈ?åòÁ¸8v„ÄÀ vŸ¨Ü·<ÐPþàÈÏ8ù£uÙ;ü¦B~ïï¼åÀ;qƒƒìIK@÷”¯k ‚-¿w1HÎò»"÷ ~ T5ÍCÀW~Ä`¼ßwŸè$~r}i!¸£ÁÊýË?Ä (¿ 7òßèÊ?+{oÿÄOøõtc€†šZª¢™øÉ÷o#†î®ct
Ò–’€ R¾qƒ ò{#¿¿ü~gû ùŸ56.KB!ªk¨jœ à+ö#B±éê>ÎÑS'Ù›"@Ëå›Á
€ò»q#ó$ÉŸÄ»Tˆ-
‡¨¯ª¦¦a6þòF ]½ïÐ9 Ê åIDATxì×A
Â0ФÖû Xm¤‹Â0Dƒ`iïÁ'C@\Ô?ØÂ) €ZÎçÔ
~Tü¤†3ÍÓ?·Îþ<
Ö2ê—,i\½ÄÛ ø[˜- åç£TôpÞŽ9Ü_ÿO >eë&}åO?”þÈîòˆêŸ_ïÚø®[úW'; @ù3Bñcáïû™²„ä×€á Ôq©Ã<(~*ý3䑾ËP~Þì{Œ\W}Ç¿ç¾çÎÌî̾w½¯_±ÇI0 Nœ‡Ð ‚F”Gj‰J©(RU!
j%þ*åòG‹jK%¤¢¡R* ´”ïk—'âË[è² kQ
€’_‘*û}ÊõÅz€ÛE˜ ìÄ=¿.¥<…’?‰j æ—ƒyåbíÎþ’máF!š¼"†1!ßè:I
ëqÜ(S?¼4×ú% €¾ñ#J…šá§„×£û€‚m‘ƒ®m<
DX0¹€!¥"BK=þÓ—=,!†®f®¼¥ätö
Ë1ó…NS7LC×Mb˜¦Æ£‚G”{Fú^¶WÂæÂ¥:‹|
€"9zÏ Àt
òg‰Ñ}A¸üõÂèp@S¦ÀЖƒ€T~Wþ
…’_ɯ'äw ¸2y™ GÆJÄ”W@®4zïðÐ vîØwpW_O[î,ꆮ@KŽ.€¯…s0Îâ×퀊م
ž8Q¹rêð̹#³"
Z üŒ„RæP&iË´d<?!²Q(ù•ü‰Þß‘Éɸ ùm)¼”~ËÝ#w=öÁGïÜwàŽ‘Þ’Y*˜p š¦!¤ ”DzÇïkÒóøg ,âð)EDc#ŽfÛ—.5_ûÅ·NÏœ|î2o ði'‚@Æ—i#û{4!?£Pò«É=q )6œTìD wûÁÜÿÄû>ñÁmÃýn_ÉFWÑ\MšmŽj“Á ((C&‚3@ !¥CŠ`5~@Ñ^MÝóů_xnò•ÿüò6—d)ßÈèÕ³ÒNU Q¢äJþ[‹Ž7(j_ŒH$Ù[
íþ÷}öñ'ßÿñíÚº%7Úçbk#½yä ¨¶Ö$fˆ˜€F M‹cšLÛFζàæ 8–Ë4ÉÐðö’Ù»³{êÌ‘I -)²‡ì´â‡24%½ŒD¡äWòo¸B.]*“ÑýOîx÷?ùÉÑþž\ÙÄpƒÁ.–I°ÒŒ0» ¢îEq½ÈÆ †¡Ã´l\{õjb``¬Ø‚kÌœ>< ˆ—¼&äâÓŒÆK¡äW¤ÄÇuÌŠ#¹ò`þ] ûÂçwŽ
÷•ó†ºlŒôæPptÔ[ ÓK>ª!åHñºË2aš&zÇ»'&ÎN7'Sò'ÅdB™äȾHEq Ñ ¸õd¯ŒK.Œ ÓBí|è÷îܳm|Ì6t”‹úK:\”Ë-ŠIño –¥£¿·lÜ÷Ø‡ß ÀJt \ÊMeÂD"–j J~Åu, ДH|ÇݼǶMÝ15tä4\
¦!C=ŸáfbÄU€Žm;woÉw–˜‰9‰[“LáùÆz(”üŠ´üY[v»=}ý{×d4
gëp- \ žÏÑò)8ÇME×
ÀèÐݽuß–Ä -5@É“¹þr_¡¦÷*DÆÚw’§£G©ÃÍ» `舑ÏïA@Ä8n6:Y¡Á-t¥ü†ŒžZ¨#2ÅW¨ž_qC»éBïpÙÍÛVòSιì¡u¬aè6 Rî.'ÅOÎÝßxO…’_±1KCLÓÉ9¦©AÎÚ (åˆ1uÀ2u€`Óp;º
ô´ø›»}·BɯáÕ«V;ˆ ”í€Ç}kض×Ò m¢üË SõßþìP…’_!® û¯ÉÙ…Å
ø”£0,7(r–Ž¼£Ç½ÿÍ„ €
å|vâÕù×1’/ Pò+n)Zبøg^=òVÛç4Z>CµAQ÷(ttä̸0 íÆ¥ç@Ä"pÎpô×G*ógÌ^ç#=…šá§¸ S“Ë~Í™ó/ÎF÷ß12¼e„3N ]@# [ƒ¡´ƒÕD\ü¿{ú0¤« @Xˆ 6&&¯†ßýê§æ7 ¬ ¨Ë´ÒëõUC äWÜ8Yûù›"
õÊìäÅΑ{tww Ñ,±DÂ("gàâZE1€sñº{ûVËCce Nó$¸Ó‹«óËÑ÷¾ñ¥£óg_˜ °"SË–ÿ¦¬ÚS(ùé|äÕh/ÏÒɳG_1zví*öŒ÷äù)FW¢ƒh6(#h‡ìú{„¡ÖÒeÔ® …ëO€wÝ‹s³^øíøÜKWýè,€åDj‰å½íì¹ü
%¿âÆzþì
@ó•èò‰_žðíþ’Ù½wX×4- LÀäË0iQP‡ YÐ "Ò{ú‚AðY|ÕËG1;uyÛ€|/ŸjþÇW?}¤rñèe)|U^eÙFbM²äçP¨Í<7wŸ¿Ä6_ J zv>üôC‡Þû‡OïßÙ۱ù —x|4ðAa‚itp¡‚<„& l¢Ö
qiA`¾”ÆæFÙ/úÝ«¯üð OF~³’IfYF–ýð’k÷7¿ìW¨ž_à yÕ+'Ï¿røDÝ(i]÷ô„i6_8E×yoAê0x„6ÀÂs+NÏ
TÚ&Ü}˜Xâíï}ýÙW.<ÿïgyJѱ”êõk ZÉ^óK~…’_Uhä7M
½âå Ÿœ™_ÂàƒãNç¨]‹ "À8ã~\XàxmŠ#4Ê@y7áð§óóÇš —gTe²ÄoJñÛ‰ Ÿ©Q~%¿bó iéïe[ž>³tîøá³aé®!wèþr§Ù$÷ „ @ÐSÓ §f8¬ò(ZOø?ßüÒé /üÛ9 …Õ
įKñ[ˆ¯Pò+~‹@z - [kUÀOÎ5>·w×Û†]R#k äg¦# »"PèÝŽzdµð÷Ÿ:¶|õÄŒ|9!¦ø©º¢ÍíõJ~ÉœF›½ ˆX‹`”Íœ~~JtíêØñH_‘O‘åzˆ.r„Fë
ÿûkŸy¹µt¥"å^A¶ø ñ©_ɯ¸5÷ÿ"•ÌÍ3gbæÜÑé±ýï~ ££Ûš›¹ŠWg :û·‰òϧο0%Å®AöüÉûû„ø^BüH
ð©¹ýŠ[»Ý“†RJ_JÚJH[÷ë W&Îœ«‹.,6€šðCʦ_{î²ü~S¦!SOü~3¹ÿ#û
µ“bSÉ–-û €
ÒÐçš‹€Ä0¡kºàŒJ©eRÛpËéûû['¾Bõü
±Áý~$C!cÊdt|Ï ÃÔÑQ0a®^Ë¥Ncøî·õ%¿ŸNº¼OK¯Ä£äWÍÔ|àsOíîÌ[¶tYè+jý€¼åÏìÏ•sP¨?Åm7ð§Éè2FòÔ^Í´‹}øÙ=ñŽ'?ÐݱúÖÔÐ^ Ó‹˜®=å »wÇ›&Oþj‚…^ºÄ§Y§êf "…’_qk–ùʘ l·´ewß[ÿà‹ŸzüÐÛßß_vuC®
̵Ï#×9 fucy¥Žr¹»0¼ïm;¦'fÛ+³5 Q"‰G‡‰Ü2J~%>IˆŸ>Ù7¿óÐïßûøÓŸþÛCoÙÿÀhA3t¬/íµ[@œnä»Æ`YV
Ü‚³ýÞC{˜YÄÒÕSs‚Ñ(k@O‰ÿÆAɯJ}SŠï\;§wïÁ|á¿ó}yïÎÑþíC.) xX?°ÓöÎC˜e × ÄYÈçÀ!³-cϾv”¶Ý¿£2{yº½2ç O6R(ù·â,3¹ÄwסÞóøÓŸùêüéwv uØ;·0ÜíÄ'öV›œËžå`u‚ÚƒÐ4
¶c£Ãu°ê> Ë ãccåÑ}‡öS³ Í ÎD¢ÚÈB@¡äWlz¹¯Ëe¾ÓÑ×ñè3ó±CO<õWwï éqÈ C«â÷XñÝ“• ¾ÜÚ›0¹Æ« ÄA”ߺ~¯aè°lŽiÀ±-ô–;¬mwÜ»'7|ßö¹Ë§&ƒæR½¦@F¡äßT”øZZüΡÝ]}ô¯?÷Ö‡þÑXÉÙÚgã®Ñ t]ëñÏͶPkR@b¶'aù“ <„ïîÑ´ô‘ÜñU×€œm¡-#}½; Ü?5y~«Ny HÆ,C‘…’_qãdîõn¿¿÷í }öï |Ó}ïî+å´Cö çQ*˜¨Ôœñ°ÜˆÀ…À\0¸ÕçÚ 8·{ ÌÒ†ç󛺆ÎRÉ Øqÿþ¹¹é©úüD-)ýoù0N…’_õúša»=óÅ¿Xÿ=¥¢ír°{¸×10W
pzÊCµ Ê;å#¾úq͉u?õ¨~ô'Ɔ
€®k(;ìÒ–½{Ww
zmmÃÄ#@–x-6ç(n…’_õú:d¯ÿÀ‡ž}âàCoýlG>gné2pçh ®Ùå §¦qÉ/Åg öªøVí˜ôT@@X ¤=æŽ š¹áé¼ÊåNÇ·zÊGtQr*ñæ Ü¡PÓ{Õ`Ÿaæ:;î>ðçÝ¥¢m›@ÉA¹`Æ'ö\œõPk²uñ ÷á. ^á—:jXwTèþ ì™ïC *ØK4è8ðà£÷ ÞùÈn E y 99þ`f Ü©Pò+nÚ³ýžÚ6Ø×5 9SCÞÑ°ÆÂ
EµÆâ æÃl]€;ýÕë Ž¤ôœó8kètÆ•ï@TŽ3Š,t
0u ÔQ0ú·îÛ Àà(ùÕ’^Å͇dmßïìíëÌ»6 ha¦ÐAC Íå+ ÕI8Í«0ià‰éøk _cÁŒsPÅáÍŸ!œüxn ¤¸Ðlðø X½rw0\ô Ž
JñsR~3}VÿÍŸ ¤Pò«é¼
} 2.r ÌêKµ;À‹ÛÅã0–΋.I Ã"¾&~†Œ½f×Þת勇×>óB5[ ~îÐ>´[+\Jo03z}…’_qSúÜ¥ZÛóÃ΂kP®ÃkÔ@à L–ñ\^Aˆ?!¼ ‹âïÄÂSƤôt-T†ÅW?d˜n¸ñwLj…5ªsW é
Z"D7·÷W(ù¤6w¡Qk5¼t¹>3°²4‹rß@4pÆÁ8ä„\Î Î…ˆ%æŒÅWÆ…”žÆâs.Rù>ŒâÏ*-
Í^ Ú‹Ðm,âh®,ú ѵŒR_¡äWÜ$H2õ™3jµ:Ådž{kó³ÿ‹b×4‚¶?¤à,Še— Ʋ‹báe¹ÙIJ3ÈF`½
hÍ>4¨íÀ*ôc®²Hk³ë; )”üŠMìCJ4~þøóß¾oïÞ}ºÝ¯UWj¸tî5¬áyí¸¼OÂcé¹,ù8‰k$K.ŧñ{5ÓínL‡ý(ê ºÆA9púÔÉZ}îÜÊFÏõUɯäWlÆAªRþ‰—¾|âÑw-íÞ6Úè}˜™º ]3@©¼÷‡€to]v ëÂ3Yþ³Xö5é¹ ô )Ã|PÂoœèè5ª°û`brJ¼òóo_ @7Þº$£ñP¨~Š×7ºŸ\É'c
ñ˜±¸}÷}ó=ãzsòß“åüµž<¤4–9ŠÖ®|õÊÖ ë „Ñj("ÁÃÕ,…œó·¡…ö“‰–V2÷<2ÞQÐ3'À"
ÆX,º ¼‹…éšìqÖK}?d"
+QÁ¦Â~p.С '¯a`ÏA\¾z©vìû_> Ô¦æ4Òâ'zýè:ö(”ü¿Õãq2„—q®EØ3§ÏN^¬h½ûzï|¬ù Y©Ì ¤a$àQüÚ§ aÈá a4C‹´„©` ³A?|fÀÕZèvB m‡Ñ3ÎN¿øã¹s?ÿúyêU– 4Éêñ…Œ’ü6€à…š» ½½œVëÊ…5 JqˆÖ5zï;ön¿ïñ»J]=½ÁÒ%â7«`¡Á9 ÆW ·
: ÛF±Ôf刦ξX›>ùÜmVj‰2?ë ¿:€–ŒŸµõwö)?ê¡’_A²–íÚ&s ó>˜\p&LƱöÚ‚²1@Ž ‘ƒ€ËVƒµ-o:ÅÎÒÈÞ>Ë)8ùŽ.«P,YŒÆÁXHthš.€†¼±Ra¡ïñÆâ%¿½<Ó†ˆ(@H
!ñ"ðôÕ hiiXûŽ „@àùÑË\`nƒF€¯E (ù¥~_Ézò#~m| çÚëü[üoòë]* Ç™+æ?ýðò ”¿
À—I6LF¤þA…zί ëõ¹¶gg^×´Û®Ó(í±‹?=¾ðÔ™+Íógr5ù' %¿ªh$œj#‚®ÜnЈE vê P]¾&2iJ~uï?³ÜþÖ¹©æ]yC{ÞÊ l@¥ ²KóÞáäúþ—ú*Ô=¿ì3gíuºŽöö‚cî–ï-Î… ˆäZ=y»À84 "´uùDZÀL E" "YªCõ׺&†äwâ+yÑy‰£‰§ M ^ê±`”ø …’_ô'äwäã¼¼Œ 'cH7éIAÙI.ÃÍ–Ÿ'’”:ý¨.ye‰Ò>”|m)|K¦’?ñ·ªìW™¤paBr"?2Jê´ÔZRöd•p =?O\³’þ<ýÿ
R#ü‘z¾ÿíÝÑJÄ0Pâÿÿ°-ŸŠÎí(ˆ9
Cò(7[fvãWÂϾ þY¾ÌáŽæöœž—® ÞøvxÞ‡½ú$¯yþë0â~á'„ÿ¬€ÖZ¿yͯ0¯T7¡_ÓaÔÔq/ G…ÿ»÷ú#üÂ_j^õ›ûòš0絪³ýÓ: ×ß™÷ð þª 5{oŸšv+?†{ýâHoßM šC êæú!üìæ;¶— ÅÛqןMqæaÇFá|Œúšw!øOl\NMB„ŸÆššxûûí¦ÎÍB„ŸIûóíXÿW | ~Þ–´Ó
Ûˆ IEND®B`‚ jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/package.html 0000644 0000000 0000000 00000001016 12566160406 023774 0 ustar root root
org.openstreetmap.gui.jmapviewer
This package and all sub-packages are belonging to the Java
component JMapViewer
JMapViewer is designed to run as stand-alone component without
any further requirements. Therefore please do not add any code that
depends on other libraries or applications. Only functions and methods
provided by the runtime library of Java 7 should be used.
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/TileController.java 0000644 0000000 0000000 00000005204 12604423574 025323 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import org.openstreetmap.gui.jmapviewer.interfaces.TileCache;
import org.openstreetmap.gui.jmapviewer.interfaces.TileLoader;
import org.openstreetmap.gui.jmapviewer.interfaces.TileLoaderListener;
import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
public class TileController {
protected TileLoader tileLoader;
protected TileCache tileCache;
protected TileSource tileSource;
public TileController(TileSource source, TileCache tileCache, TileLoaderListener listener) {
this.tileSource = source;
this.tileLoader = new OsmTileLoader(listener);
this.tileCache = tileCache;
}
/**
* retrieves a tile from the cache. If the tile is not present in the cache
* a load job is added to the working queue of {@link TileLoader}.
*
* @param tilex the X position of the tile
* @param tiley the Y position of the tile
* @param zoom the zoom level of the tile
* @return specified tile from the cache or null if the tile
* was not found in the cache.
*/
public Tile getTile(int tilex, int tiley, int zoom) {
int max = 1 << zoom;
if (tilex < 0 || tilex >= max || tiley < 0 || tiley >= max)
return null;
Tile tile = tileCache.getTile(tileSource, tilex, tiley, zoom);
if (tile == null) {
tile = new Tile(tileSource, tilex, tiley, zoom);
tileCache.addTile(tile);
tile.loadPlaceholderFromCache(tileCache);
}
if (tile.error) {
tile.loadPlaceholderFromCache(tileCache);
}
if (!tile.isLoaded()) {
tileLoader.createTileLoaderJob(tile).submit();
}
return tile;
}
public TileCache getTileCache() {
return tileCache;
}
public void setTileCache(TileCache tileCache) {
this.tileCache = tileCache;
}
public TileLoader getTileLoader() {
return tileLoader;
}
public void setTileLoader(TileLoader tileLoader) {
this.tileLoader = tileLoader;
}
public TileSource getTileLayerSource() {
return tileSource;
}
public TileSource getTileSource() {
return tileSource;
}
public void setTileSource(TileSource tileSource) {
this.tileSource = tileSource;
}
/**
* Removes all jobs from the queue that are currently not being processed.
*
*/
public void cancelOutstandingJobs() {
tileLoader.cancelOutstandingTasks();
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/DefaultMapController.java 0000644 0000000 0000000 00000014046 12641052742 026450 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
/**
* Default map controller which implements map moving by pressing the right
* mouse button and zooming by double click or by mouse wheel.
*
* @author Jan Peter Stotz
*
*/
public class DefaultMapController extends JMapController implements MouseListener, MouseMotionListener,
MouseWheelListener {
private static final int MOUSE_BUTTONS_MASK = MouseEvent.BUTTON3_DOWN_MASK | MouseEvent.BUTTON1_DOWN_MASK
| MouseEvent.BUTTON2_DOWN_MASK;
private static final int MAC_MOUSE_BUTTON3_MASK = MouseEvent.CTRL_DOWN_MASK | MouseEvent.BUTTON1_DOWN_MASK;
private Point lastDragPoint;
private boolean isMoving;
private boolean movementEnabled = true;
private int movementMouseButton = MouseEvent.BUTTON3;
private int movementMouseButtonMask = MouseEvent.BUTTON3_DOWN_MASK;
private boolean wheelZoomEnabled = true;
private boolean doubleClickZoomEnabled = true;
public DefaultMapController(JMapViewer map) {
super(map);
}
@Override
public void mouseDragged(MouseEvent e) {
if (!movementEnabled || !isMoving)
return;
// Is only the selected mouse button pressed?
if ((e.getModifiersEx() & MOUSE_BUTTONS_MASK) == movementMouseButtonMask
|| isPlatformOsx() && e.getModifiersEx() == MAC_MOUSE_BUTTON3_MASK) {
Point p = e.getPoint();
if (lastDragPoint != null) {
int diffx = lastDragPoint.x - p.x;
int diffy = lastDragPoint.y - p.y;
map.moveMap(diffx, diffy);
}
lastDragPoint = p;
}
}
@Override
public void mouseClicked(MouseEvent e) {
if (doubleClickZoomEnabled && e.getClickCount() == 2 && e.getButton() == MouseEvent.BUTTON1) {
map.zoomIn(e.getPoint());
}
}
@Override
public void mousePressed(MouseEvent e) {
if (e.getButton() == movementMouseButton || isPlatformOsx() && e.getModifiersEx() == MAC_MOUSE_BUTTON3_MASK) {
lastDragPoint = null;
isMoving = true;
}
}
@Override
public void mouseReleased(MouseEvent e) {
if (e.getButton() == movementMouseButton || isPlatformOsx() && e.getButton() == MouseEvent.BUTTON1) {
lastDragPoint = null;
isMoving = false;
}
}
@Override
public void mouseWheelMoved(MouseWheelEvent e) {
if (wheelZoomEnabled) {
map.setZoom(map.getZoom() - e.getWheelRotation(), e.getPoint());
}
}
public boolean isMovementEnabled() {
return movementEnabled;
}
/**
* Enables or disables that the map pane can be moved using the mouse.
*
* @param movementEnabled {@code true} to allow the map pane to be moved using the mouse
*/
public void setMovementEnabled(boolean movementEnabled) {
this.movementEnabled = movementEnabled;
}
public int getMovementMouseButton() {
return movementMouseButton;
}
/**
* Sets the mouse button that is used for moving the map. Possible values are:
*
* - {@link MouseEvent#BUTTON1} (left mouse button)
* - {@link MouseEvent#BUTTON2} (middle mouse button)
* - {@link MouseEvent#BUTTON3} (right mouse button)
*
*
* @param movementMouseButton the mouse button that is used for moving the map
*/
public void setMovementMouseButton(int movementMouseButton) {
this.movementMouseButton = movementMouseButton;
switch (movementMouseButton) {
case MouseEvent.BUTTON1:
movementMouseButtonMask = MouseEvent.BUTTON1_DOWN_MASK;
break;
case MouseEvent.BUTTON2:
movementMouseButtonMask = MouseEvent.BUTTON2_DOWN_MASK;
break;
case MouseEvent.BUTTON3:
movementMouseButtonMask = MouseEvent.BUTTON3_DOWN_MASK;
break;
default:
throw new RuntimeException("Unsupported button");
}
}
public boolean isWheelZoomEnabled() {
return wheelZoomEnabled;
}
public void setWheelZoomEnabled(boolean wheelZoomEnabled) {
this.wheelZoomEnabled = wheelZoomEnabled;
}
public boolean isDoubleClickZoomEnabled() {
return doubleClickZoomEnabled;
}
public void setDoubleClickZoomEnabled(boolean doubleClickZoomEnabled) {
this.doubleClickZoomEnabled = doubleClickZoomEnabled;
}
@Override
public void mouseEntered(MouseEvent e) {
}
@Override
public void mouseExited(MouseEvent e) {
}
@Override
public void mouseMoved(MouseEvent e) {
// Mac OSX simulates with ctrl + mouse 1 the second mouse button hence no dragging events get fired.
//
if (isPlatformOsx()) {
if (!movementEnabled || !isMoving)
return;
// Is only the selected mouse button pressed?
if (e.getModifiersEx() == MouseEvent.CTRL_DOWN_MASK) {
Point p = e.getPoint();
if (lastDragPoint != null) {
int diffx = lastDragPoint.x - p.x;
int diffy = lastDragPoint.y - p.y;
map.moveMap(diffx, diffy);
}
lastDragPoint = p;
}
}
}
/**
* Replies true if we are currently running on OSX
*
* @return true if we are currently running on OSX
*/
public static boolean isPlatformOsx() {
String os = System.getProperty("os.name");
return os != null && os.toLowerCase().startsWith("mac os x");
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/MapObjectImpl.java 0000644 0000000 0000000 00000007271 12566160406 025055 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Stroke;
import javax.swing.UIManager;
public abstract class MapObjectImpl {
private Layer layer;
private String name;
private Style style;
private Boolean visible;
public MapObjectImpl(String name) {
this(null, name, null);
}
public MapObjectImpl(Layer layer) {
this(layer, null, null);
}
public MapObjectImpl(Layer layer, String name, Style style) {
super();
this.layer = layer;
this.name = name;
this.style = style;
}
public Layer getLayer() {
return layer;
}
public void setLayer(Layer layer) {
this.layer = layer;
}
public Style getStyle() {
return style;
}
public Style getStyleAssigned() {
return style == null ? (layer == null ? null : layer.getStyle()) : style;
}
public void setStyle(Style style) {
this.style = style;
}
public Color getColor() {
Style styleAssigned = getStyleAssigned();
return styleAssigned == null ? null : getStyleAssigned().getColor();
}
public void setColor(Color color) {
if (style == null && color != null) style = new Style();
if (style != null) style.setColor(color);
}
public Color getBackColor() {
Style styleAssigned = getStyleAssigned();
return styleAssigned == null ? null : getStyleAssigned().getBackColor();
}
public void setBackColor(Color backColor) {
if (style == null && backColor != null) style = new Style();
if (style != null) style.setBackColor(backColor);
}
public Stroke getStroke() {
Style styleAssigned = getStyleAssigned();
return styleAssigned == null ? null : getStyleAssigned().getStroke();
}
public void setStroke(Stroke stroke) {
if (style == null && stroke != null) style = new Style();
if (style != null) style.setStroke(stroke);
}
public Font getFont() {
Style styleAssigned = getStyleAssigned();
return styleAssigned == null ? null : getStyleAssigned().getFont();
}
public void setFont(Font font) {
if (style == null && font != null) style = new Style();
if (style != null) style.setFont(font);
}
private boolean isVisibleLayer() {
return layer == null || layer.isVisible() == null ? true : layer.isVisible();
}
public boolean isVisible() {
return visible == null ? isVisibleLayer() : visible.booleanValue();
}
public void setVisible(Boolean visible) {
this.visible = visible;
}
public String getName() {
return name;
}
public void setName(String txt) {
this.name = txt;
}
public static Font getDefaultFont() {
Font f = UIManager.getDefaults().getFont("TextField.font");
if (f == null) {
f = Font.decode(null);
}
return new Font(f.getName(), Font.BOLD, f.getSize());
}
public void paintText(Graphics g, Point position) {
if (name != null && g != null && position != null) {
if (getFont() == null) {
Font f = getDefaultFont();
setFont(new Font(f.getName(), Font.BOLD, f.getSize()));
}
g.setColor(Color.DARK_GRAY);
g.setFont(getFont());
g.drawString(name, position.x+MapMarkerDot.DOT_RADIUS+2, position.y+MapMarkerDot.DOT_RADIUS);
}
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/JMapViewer.java 0000644 0000000 0000000 00000113662 12641052742 024377 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.EventListenerList;
import org.openstreetmap.gui.jmapviewer.events.JMVCommandEvent;
import org.openstreetmap.gui.jmapviewer.events.JMVCommandEvent.COMMAND;
import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
import org.openstreetmap.gui.jmapviewer.interfaces.JMapViewerEventListener;
import org.openstreetmap.gui.jmapviewer.interfaces.MapMarker;
import org.openstreetmap.gui.jmapviewer.interfaces.MapPolygon;
import org.openstreetmap.gui.jmapviewer.interfaces.MapRectangle;
import org.openstreetmap.gui.jmapviewer.interfaces.TileCache;
import org.openstreetmap.gui.jmapviewer.interfaces.TileLoader;
import org.openstreetmap.gui.jmapviewer.interfaces.TileLoaderListener;
import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
import org.openstreetmap.gui.jmapviewer.tilesources.OsmTileSource;
/**
* Provides a simple panel that displays pre-rendered map tiles loaded from the
* OpenStreetMap project.
*
* @author Jan Peter Stotz
* @author Jason Huntley
*/
public class JMapViewer extends JPanel implements TileLoaderListener {
public static boolean debug;
/**
* Vectors for clock-wise tile painting
*/
private static final Point[] move = {new Point(1, 0), new Point(0, 1), new Point(-1, 0), new Point(0, -1)};
public static final int MAX_ZOOM = 22;
public static final int MIN_ZOOM = 0;
protected transient List mapMarkerList;
protected transient List mapRectangleList;
protected transient List mapPolygonList;
protected boolean mapMarkersVisible;
protected boolean mapRectanglesVisible;
protected boolean mapPolygonsVisible;
protected boolean tileGridVisible;
protected boolean scrollWrapEnabled;
protected transient TileController tileController;
/**
* x- and y-position of the center of this map-panel on the world map
* denoted in screen pixel regarding the current zoom level.
*/
protected Point center;
/**
* Current zoom level
*/
protected int zoom;
protected JSlider zoomSlider;
protected JButton zoomInButton;
protected JButton zoomOutButton;
public enum ZOOM_BUTTON_STYLE {
HORIZONTAL,
VERTICAL
}
protected ZOOM_BUTTON_STYLE zoomButtonStyle;
protected transient TileSource tileSource;
protected transient AttributionSupport attribution = new AttributionSupport();
protected EventListenerList evtListenerList = new EventListenerList();
/**
* Creates a standard {@link JMapViewer} instance that can be controlled via
* mouse: hold right mouse button for moving, double click left mouse button
* or use mouse wheel for zooming. Loaded tiles are stored in a
* {@link MemoryTileCache} and the tile loader uses 4 parallel threads for
* retrieving the tiles.
*/
public JMapViewer() {
this(new MemoryTileCache());
new DefaultMapController(this);
}
/**
* Creates a new {@link JMapViewer} instance.
* @param tileCache The cache where to store tiles
* @deprecated @param downloadThreadCount not used anymore
*/
@Deprecated
public JMapViewer(TileCache tileCache, int downloadThreadCount) {
this(tileCache);
}
/**
* Creates a new {@link JMapViewer} instance.
* @param tileCache The cache where to store tiles
*
*/
public JMapViewer(TileCache tileCache) {
tileSource = new OsmTileSource.Mapnik();
tileController = new TileController(tileSource, tileCache, this);
mapMarkerList = Collections.synchronizedList(new LinkedList());
mapPolygonList = Collections.synchronizedList(new LinkedList());
mapRectangleList = Collections.synchronizedList(new LinkedList());
mapMarkersVisible = true;
mapRectanglesVisible = true;
mapPolygonsVisible = true;
tileGridVisible = false;
setLayout(null);
initializeZoomSlider();
setMinimumSize(new Dimension(tileSource.getTileSize(), tileSource.getTileSize()));
setPreferredSize(new Dimension(400, 400));
setDisplayPosition(new Coordinate(50, 9), 3);
}
@Override
public String getToolTipText(MouseEvent event) {
return super.getToolTipText(event);
}
protected void initializeZoomSlider() {
zoomSlider = new JSlider(MIN_ZOOM, tileController.getTileSource().getMaxZoom());
zoomSlider.setOrientation(JSlider.VERTICAL);
zoomSlider.setBounds(10, 10, 30, 150);
zoomSlider.setOpaque(false);
zoomSlider.addChangeListener(new ChangeListener() {
@Override
public void stateChanged(ChangeEvent e) {
setZoom(zoomSlider.getValue());
}
});
zoomSlider.setFocusable(false);
add(zoomSlider);
int size = 18;
try {
ImageIcon icon = new ImageIcon(JMapViewer.class.getResource("images/plus.png"));
zoomInButton = new JButton(icon);
} catch (Exception e) {
zoomInButton = new JButton("+");
zoomInButton.setFont(new Font("sansserif", Font.BOLD, 9));
zoomInButton.setMargin(new Insets(0, 0, 0, 0));
}
zoomInButton.setBounds(4, 155, size, size);
zoomInButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
zoomIn();
}
});
zoomInButton.setFocusable(false);
add(zoomInButton);
try {
ImageIcon icon = new ImageIcon(JMapViewer.class.getResource("images/minus.png"));
zoomOutButton = new JButton(icon);
} catch (Exception e) {
zoomOutButton = new JButton("-");
zoomOutButton.setFont(new Font("sansserif", Font.BOLD, 9));
zoomOutButton.setMargin(new Insets(0, 0, 0, 0));
}
zoomOutButton.setBounds(8 + size, 155, size, size);
zoomOutButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
zoomOut();
}
});
zoomOutButton.setFocusable(false);
add(zoomOutButton);
}
/**
* Changes the map pane so that it is centered on the specified coordinate
* at the given zoom level.
*
* @param to
* specified coordinate
* @param zoom
* {@link #MIN_ZOOM} <= zoom level <= {@link #MAX_ZOOM}
*/
public void setDisplayPosition(ICoordinate to, int zoom) {
setDisplayPosition(new Point(getWidth() / 2, getHeight() / 2), to, zoom);
}
/**
* Changes the map pane so that the specified coordinate at the given zoom
* level is displayed on the map at the screen coordinate
* mapPoint.
*
* @param mapPoint
* point on the map denoted in pixels where the coordinate should
* be set
* @param to
* specified coordinate
* @param zoom
* {@link #MIN_ZOOM} <= zoom level <=
* {@link TileSource#getMaxZoom()}
*/
public void setDisplayPosition(Point mapPoint, ICoordinate to, int zoom) {
Point p = tileSource.latLonToXY(to, zoom);
setDisplayPosition(mapPoint, p.x, p.y, zoom);
}
public void setDisplayPosition(int x, int y, int zoom) {
setDisplayPosition(new Point(getWidth() / 2, getHeight() / 2), x, y, zoom);
}
public void setDisplayPosition(Point mapPoint, int x, int y, int zoom) {
if (zoom > tileController.getTileSource().getMaxZoom() || zoom < MIN_ZOOM)
return;
// Get the plain tile number
Point p = new Point();
p.x = x - mapPoint.x + getWidth() / 2;
p.y = y - mapPoint.y + getHeight() / 2;
center = p;
setIgnoreRepaint(true);
try {
int oldZoom = this.zoom;
this.zoom = zoom;
if (oldZoom != zoom) {
zoomChanged(oldZoom);
}
if (zoomSlider.getValue() != zoom) {
zoomSlider.setValue(zoom);
}
} finally {
setIgnoreRepaint(false);
repaint();
}
}
/**
* Sets the displayed map pane and zoom level so that all chosen map elements are visible.
* @param markers whether to consider markers
* @param rectangles whether to consider rectangles
* @param polygons whether to consider polygons
*/
public void setDisplayToFitMapElements(boolean markers, boolean rectangles, boolean polygons) {
int nbElemToCheck = 0;
if (markers && mapMarkerList != null)
nbElemToCheck += mapMarkerList.size();
if (rectangles && mapRectangleList != null)
nbElemToCheck += mapRectangleList.size();
if (polygons && mapPolygonList != null)
nbElemToCheck += mapPolygonList.size();
if (nbElemToCheck == 0)
return;
int xMin = Integer.MAX_VALUE;
int yMin = Integer.MAX_VALUE;
int xMax = Integer.MIN_VALUE;
int yMax = Integer.MIN_VALUE;
int mapZoomMax = tileController.getTileSource().getMaxZoom();
if (markers && mapMarkerList != null) {
synchronized (mapMarkerList) {
for (MapMarker marker : mapMarkerList) {
if (marker.isVisible()) {
Point p = tileSource.latLonToXY(marker.getCoordinate(), mapZoomMax);
xMax = Math.max(xMax, p.x);
yMax = Math.max(yMax, p.y);
xMin = Math.min(xMin, p.x);
yMin = Math.min(yMin, p.y);
}
}
}
}
if (rectangles && mapRectangleList != null) {
synchronized (mapRectangleList) {
for (MapRectangle rectangle : mapRectangleList) {
if (rectangle.isVisible()) {
Point bottomRight = tileSource.latLonToXY(rectangle.getBottomRight(), mapZoomMax);
Point topLeft = tileSource.latLonToXY(rectangle.getTopLeft(), mapZoomMax);
xMax = Math.max(xMax, bottomRight.x);
yMax = Math.max(yMax, topLeft.y);
xMin = Math.min(xMin, topLeft.x);
yMin = Math.min(yMin, bottomRight.y);
}
}
}
}
if (polygons && mapPolygonList != null) {
synchronized (mapPolygonList) {
for (MapPolygon polygon : mapPolygonList) {
if (polygon.isVisible()) {
for (ICoordinate c : polygon.getPoints()) {
Point p = tileSource.latLonToXY(c, mapZoomMax);
xMax = Math.max(xMax, p.x);
yMax = Math.max(yMax, p.y);
xMin = Math.min(xMin, p.x);
yMin = Math.min(yMin, p.y);
}
}
}
}
}
int height = Math.max(0, getHeight());
int width = Math.max(0, getWidth());
int newZoom = mapZoomMax;
int x = xMax - xMin;
int y = yMax - yMin;
while (x > width || y > height) {
newZoom--;
x >>= 1;
y >>= 1;
}
x = xMin + (xMax - xMin) / 2;
y = yMin + (yMax - yMin) / 2;
int z = 1 << (mapZoomMax - newZoom);
x /= z;
y /= z;
setDisplayPosition(x, y, newZoom);
}
/**
* Sets the displayed map pane and zoom level so that all map markers are visible.
*/
public void setDisplayToFitMapMarkers() {
setDisplayToFitMapElements(true, false, false);
}
/**
* Sets the displayed map pane and zoom level so that all map rectangles are visible.
*/
public void setDisplayToFitMapRectangles() {
setDisplayToFitMapElements(false, true, false);
}
/**
* Sets the displayed map pane and zoom level so that all map polygons are visible.
*/
public void setDisplayToFitMapPolygons() {
setDisplayToFitMapElements(false, false, true);
}
/**
* @return the center
*/
public Point getCenter() {
return center;
}
/**
* @param center the center to set
*/
public void setCenter(Point center) {
this.center = center;
}
/**
* Calculates the latitude/longitude coordinate of the center of the
* currently displayed map area.
*
* @return latitude / longitude
*/
public ICoordinate getPosition() {
return tileSource.xyToLatLon(center, zoom);
}
/**
* Converts the relative pixel coordinate (regarding the top left corner of
* the displayed map) into a latitude / longitude coordinate
*
* @param mapPoint
* relative pixel coordinate regarding the top left corner of the
* displayed map
* @return latitude / longitude
*/
public ICoordinate getPosition(Point mapPoint) {
return getPosition(mapPoint.x, mapPoint.y);
}
/**
* Converts the relative pixel coordinate (regarding the top left corner of
* the displayed map) into a latitude / longitude coordinate
*
* @param mapPointX X coordinate
* @param mapPointY Y coordinate
* @return latitude / longitude
*/
public ICoordinate getPosition(int mapPointX, int mapPointY) {
int x = center.x + mapPointX - getWidth() / 2;
int y = center.y + mapPointY - getHeight() / 2;
return tileSource.xyToLatLon(x, y, zoom);
}
/**
* Calculates the position on the map of a given coordinate
*
* @param lat latitude
* @param lon longitude
* @param checkOutside check if the point is outside the displayed area
* @return point on the map or null if the point is not visible
* and checkOutside set to true
*/
public Point getMapPosition(double lat, double lon, boolean checkOutside) {
Point p = tileSource.latLonToXY(lat, lon, zoom);
p.translate(-(center.x - getWidth() / 2), -(center.y - getHeight() /2));
if (checkOutside && (p.x < 0 || p.y < 0 || p.x > getWidth() || p.y > getHeight())) {
return null;
}
return p;
}
/**
* Calculates the position on the map of a given coordinate
*
* @param lat latitude
* @param lon longitude
* @return point on the map or null if the point is not visible
*/
public Point getMapPosition(double lat, double lon) {
return getMapPosition(lat, lon, true);
}
/**
* Calculates the position on the map of a given coordinate
*
* @param lat Latitude
* @param lon longitude
* @param offset Offset respect Latitude
* @param checkOutside check if the point is outside the displayed area
* @return Integer the radius in pixels
*/
public Integer getLatOffset(double lat, double lon, double offset, boolean checkOutside) {
Point p = tileSource.latLonToXY(lat, lon, zoom);
int y = p.y - center.y - getHeight() / 2;
if (checkOutside && (y < 0 || y > getHeight())) {
return null;
}
return y;
}
/**
* Calculates the position on the map of a given coordinate
*
* @param marker MapMarker object that define the x,y coordinate
* @param p coordinate
* @return Integer the radius in pixels
*/
public Integer getRadius(MapMarker marker, Point p) {
if (marker.getMarkerStyle() == MapMarker.STYLE.FIXED)
return (int) marker.getRadius();
else if (p != null) {
Integer radius = getLatOffset(marker.getLat(), marker.getLon(), marker.getRadius(), false);
radius = radius == null ? null : p.y - radius.intValue();
return radius;
} else
return null;
}
/**
* Calculates the position on the map of a given coordinate
*
* @param coord coordinate
* @return point on the map or null if the point is not visible
*/
public Point getMapPosition(Coordinate coord) {
if (coord != null)
return getMapPosition(coord.getLat(), coord.getLon());
else
return null;
}
/**
* Calculates the position on the map of a given coordinate
*
* @param coord coordinate
* @param checkOutside check if the point is outside the displayed area
* @return point on the map or null if the point is not visible
* and checkOutside set to true
*/
public Point getMapPosition(ICoordinate coord, boolean checkOutside) {
if (coord != null)
return getMapPosition(coord.getLat(), coord.getLon(), checkOutside);
else
return null;
}
/**
* Gets the meter per pixel.
*
* @return the meter per pixel
*/
public double getMeterPerPixel() {
Point origin = new Point(5, 5);
Point center = new Point(getWidth() / 2, getHeight() / 2);
double pDistance = center.distance(origin);
ICoordinate originCoord = getPosition(origin);
ICoordinate centerCoord = getPosition(center);
double mDistance = tileSource.getDistance(originCoord.getLat(), originCoord.getLon(),
centerCoord.getLat(), centerCoord.getLon());
return mDistance / pDistance;
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
int iMove = 0;
int tilesize = tileSource.getTileSize();
int tilex = center.x / tilesize;
int tiley = center.y / tilesize;
int offsx = center.x % tilesize;
int offsy = center.y % tilesize;
int w2 = getWidth() / 2;
int h2 = getHeight() / 2;
int posx = w2 - offsx;
int posy = h2 - offsy;
int diffLeft = offsx;
int diffRight = tilesize - offsx;
int diffTop = offsy;
int diffBottom = tilesize - offsy;
boolean startLeft = diffLeft < diffRight;
boolean startTop = diffTop < diffBottom;
if (startTop) {
if (startLeft) {
iMove = 2;
} else {
iMove = 3;
}
} else {
if (startLeft) {
iMove = 1;
} else {
iMove = 0;
}
} // calculate the visibility borders
int xMin = -tilesize;
int yMin = -tilesize;
int xMax = getWidth();
int yMax = getHeight();
// calculate the length of the grid (number of squares per edge)
int gridLength = 1 << zoom;
// paint the tiles in a spiral, starting from center of the map
boolean painted = true;
int x = 0;
while (painted) {
painted = false;
for (int i = 0; i < 4; i++) {
if (i % 2 == 0) {
x++;
}
for (int j = 0; j < x; j++) {
if (xMin <= posx && posx <= xMax && yMin <= posy && posy <= yMax) {
// tile is visible
Tile tile;
if (scrollWrapEnabled) {
// in case tilex is out of bounds, grab the tile to use for wrapping
int tilexWrap = ((tilex % gridLength) + gridLength) % gridLength;
tile = tileController.getTile(tilexWrap, tiley, zoom);
} else {
tile = tileController.getTile(tilex, tiley, zoom);
}
if (tile != null) {
tile.paint(g, posx, posy, tilesize, tilesize);
if (tileGridVisible) {
g.drawRect(posx, posy, tilesize, tilesize);
}
}
painted = true;
}
Point p = move[iMove];
posx += p.x * tilesize;
posy += p.y * tilesize;
tilex += p.x;
tiley += p.y;
}
iMove = (iMove + 1) % move.length;
}
}
// outer border of the map
int mapSize = tilesize << zoom;
if (scrollWrapEnabled) {
g.drawLine(0, h2 - center.y, getWidth(), h2 - center.y);
g.drawLine(0, h2 - center.y + mapSize, getWidth(), h2 - center.y + mapSize);
} else {
g.drawRect(w2 - center.x, h2 - center.y, mapSize, mapSize);
}
// g.drawString("Tiles in cache: " + tileCache.getTileCount(), 50, 20);
// keep x-coordinates from growing without bound if scroll-wrap is enabled
if (scrollWrapEnabled) {
center.x = center.x % mapSize;
}
if (mapPolygonsVisible && mapPolygonList != null) {
synchronized (mapPolygonList) {
for (MapPolygon polygon : mapPolygonList) {
if (polygon.isVisible())
paintPolygon(g, polygon);
}
}
}
if (mapRectanglesVisible && mapRectangleList != null) {
synchronized (mapRectangleList) {
for (MapRectangle rectangle : mapRectangleList) {
if (rectangle.isVisible())
paintRectangle(g, rectangle);
}
}
}
if (mapMarkersVisible && mapMarkerList != null) {
synchronized (mapMarkerList) {
for (MapMarker marker : mapMarkerList) {
if (marker.isVisible())
paintMarker(g, marker);
}
}
}
attribution.paintAttribution(g, getWidth(), getHeight(), getPosition(0, 0), getPosition(getWidth(), getHeight()), zoom, this);
}
/**
* Paint a single marker.
* @param g Graphics used for painting
* @param marker marker to paint
*/
protected void paintMarker(Graphics g, MapMarker marker) {
Point p = getMapPosition(marker.getLat(), marker.getLon(), marker.getMarkerStyle() == MapMarker.STYLE.FIXED);
Integer radius = getRadius(marker, p);
if (scrollWrapEnabled) {
int tilesize = tileSource.getTileSize();
int mapSize = tilesize << zoom;
if (p == null) {
p = getMapPosition(marker.getLat(), marker.getLon(), false);
radius = getRadius(marker, p);
}
marker.paint(g, p, radius);
int xSave = p.x;
int xWrap = xSave;
// overscan of 15 allows up to 30-pixel markers to gracefully scroll off the edge of the panel
while ((xWrap -= mapSize) >= -15) {
p.x = xWrap;
marker.paint(g, p, radius);
}
xWrap = xSave;
while ((xWrap += mapSize) <= getWidth() + 15) {
p.x = xWrap;
marker.paint(g, p, radius);
}
} else {
if (p != null) {
marker.paint(g, p, radius);
}
}
}
/**
* Paint a single rectangle.
* @param g Graphics used for painting
* @param rectangle rectangle to paint
*/
protected void paintRectangle(Graphics g, MapRectangle rectangle) {
Coordinate topLeft = rectangle.getTopLeft();
Coordinate bottomRight = rectangle.getBottomRight();
if (topLeft != null && bottomRight != null) {
Point pTopLeft = getMapPosition(topLeft, false);
Point pBottomRight = getMapPosition(bottomRight, false);
if (pTopLeft != null && pBottomRight != null) {
rectangle.paint(g, pTopLeft, pBottomRight);
if (scrollWrapEnabled) {
int tilesize = tileSource.getTileSize();
int mapSize = tilesize << zoom;
int xTopLeftSave = pTopLeft.x;
int xTopLeftWrap = xTopLeftSave;
int xBottomRightSave = pBottomRight.x;
int xBottomRightWrap = xBottomRightSave;
while ((xBottomRightWrap -= mapSize) >= 0) {
xTopLeftWrap -= mapSize;
pTopLeft.x = xTopLeftWrap;
pBottomRight.x = xBottomRightWrap;
rectangle.paint(g, pTopLeft, pBottomRight);
}
xTopLeftWrap = xTopLeftSave;
xBottomRightWrap = xBottomRightSave;
while ((xTopLeftWrap += mapSize) <= getWidth()) {
xBottomRightWrap += mapSize;
pTopLeft.x = xTopLeftWrap;
pBottomRight.x = xBottomRightWrap;
rectangle.paint(g, pTopLeft, pBottomRight);
}
}
}
}
}
/**
* Paint a single polygon.
* @param g Graphics used for painting
* @param polygon polygon to paint
*/
protected void paintPolygon(Graphics g, MapPolygon polygon) {
List coords = polygon.getPoints();
if (coords != null && coords.size() >= 3) {
List points = new LinkedList<>();
for (ICoordinate c : coords) {
Point p = getMapPosition(c, false);
if (p == null) {
return;
}
points.add(p);
}
polygon.paint(g, points);
if (scrollWrapEnabled) {
int tilesize = tileSource.getTileSize();
int mapSize = tilesize << zoom;
List pointsWrapped = new LinkedList<>(points);
boolean keepWrapping = true;
while (keepWrapping) {
for (Point p : pointsWrapped) {
p.x -= mapSize;
if (p.x < 0) {
keepWrapping = false;
}
}
polygon.paint(g, pointsWrapped);
}
pointsWrapped = new LinkedList<>(points);
keepWrapping = true;
while (keepWrapping) {
for (Point p : pointsWrapped) {
p.x += mapSize;
if (p.x > getWidth()) {
keepWrapping = false;
}
}
polygon.paint(g, pointsWrapped);
}
}
}
}
/**
* Moves the visible map pane.
*
* @param x
* horizontal movement in pixel.
* @param y
* vertical movement in pixel
*/
public void moveMap(int x, int y) {
tileController.cancelOutstandingJobs(); // Clear outstanding load
center.x += x;
center.y += y;
repaint();
this.fireJMVEvent(new JMVCommandEvent(COMMAND.MOVE, this));
}
/**
* @return the current zoom level
*/
public int getZoom() {
return zoom;
}
/**
* Increases the current zoom level by one
*/
public void zoomIn() {
setZoom(zoom + 1);
}
/**
* Increases the current zoom level by one
* @param mapPoint point to choose as center for new zoom level
*/
public void zoomIn(Point mapPoint) {
setZoom(zoom + 1, mapPoint);
}
/**
* Decreases the current zoom level by one
*/
public void zoomOut() {
setZoom(zoom - 1);
}
/**
* Decreases the current zoom level by one
*
* @param mapPoint point to choose as center for new zoom level
*/
public void zoomOut(Point mapPoint) {
setZoom(zoom - 1, mapPoint);
}
/**
* Set the zoom level and center point for display
*
* @param zoom new zoom level
* @param mapPoint point to choose as center for new zoom level
*/
public void setZoom(int zoom, Point mapPoint) {
if (zoom > tileController.getTileSource().getMaxZoom() || zoom < tileController.getTileSource().getMinZoom()
|| zoom == this.zoom)
return;
ICoordinate zoomPos = getPosition(mapPoint);
tileController.cancelOutstandingJobs(); // Clearing outstanding load
// requests
setDisplayPosition(mapPoint, zoomPos, zoom);
this.fireJMVEvent(new JMVCommandEvent(COMMAND.ZOOM, this));
}
/**
* Set the zoom level
*
* @param zoom new zoom level
*/
public void setZoom(int zoom) {
setZoom(zoom, new Point(getWidth() / 2, getHeight() / 2));
}
/**
* Every time the zoom level changes this method is called. Override it in
* derived implementations for adapting zoom dependent values. The new zoom
* level can be obtained via {@link #getZoom()}.
*
* @param oldZoom
* the previous zoom level
*/
protected void zoomChanged(int oldZoom) {
zoomSlider.setToolTipText("Zoom level " + zoom);
zoomInButton.setToolTipText("Zoom to level " + (zoom + 1));
zoomOutButton.setToolTipText("Zoom to level " + (zoom - 1));
zoomOutButton.setEnabled(zoom > tileController.getTileSource().getMinZoom());
zoomInButton.setEnabled(zoom < tileController.getTileSource().getMaxZoom());
}
public boolean isTileGridVisible() {
return tileGridVisible;
}
public void setTileGridVisible(boolean tileGridVisible) {
this.tileGridVisible = tileGridVisible;
repaint();
}
public boolean getMapMarkersVisible() {
return mapMarkersVisible;
}
/**
* Enables or disables painting of the {@link MapMarker}
*
* @param mapMarkersVisible {@code true} to enable painting of markers
* @see #addMapMarker(MapMarker)
* @see #getMapMarkerList()
*/
public void setMapMarkerVisible(boolean mapMarkersVisible) {
this.mapMarkersVisible = mapMarkersVisible;
repaint();
}
public void setMapMarkerList(List mapMarkerList) {
this.mapMarkerList = mapMarkerList;
repaint();
}
public List getMapMarkerList() {
return mapMarkerList;
}
public void setMapRectangleList(List mapRectangleList) {
this.mapRectangleList = mapRectangleList;
repaint();
}
public List getMapRectangleList() {
return mapRectangleList;
}
public void setMapPolygonList(List mapPolygonList) {
this.mapPolygonList = mapPolygonList;
repaint();
}
public List getMapPolygonList() {
return mapPolygonList;
}
public void addMapMarker(MapMarker marker) {
mapMarkerList.add(marker);
repaint();
}
public void removeMapMarker(MapMarker marker) {
mapMarkerList.remove(marker);
repaint();
}
public void removeAllMapMarkers() {
mapMarkerList.clear();
repaint();
}
public void addMapRectangle(MapRectangle rectangle) {
mapRectangleList.add(rectangle);
repaint();
}
public void removeMapRectangle(MapRectangle rectangle) {
mapRectangleList.remove(rectangle);
repaint();
}
public void removeAllMapRectangles() {
mapRectangleList.clear();
repaint();
}
public void addMapPolygon(MapPolygon polygon) {
mapPolygonList.add(polygon);
repaint();
}
public void removeMapPolygon(MapPolygon polygon) {
mapPolygonList.remove(polygon);
repaint();
}
public void removeAllMapPolygons() {
mapPolygonList.clear();
repaint();
}
public void setZoomContolsVisible(boolean visible) {
zoomSlider.setVisible(visible);
zoomInButton.setVisible(visible);
zoomOutButton.setVisible(visible);
}
public boolean getZoomControlsVisible() {
return zoomSlider.isVisible();
}
public void setTileSource(TileSource tileSource) {
if (tileSource.getMaxZoom() > MAX_ZOOM)
throw new RuntimeException("Maximum zoom level too high");
if (tileSource.getMinZoom() < MIN_ZOOM)
throw new RuntimeException("Minimum zoom level too low");
ICoordinate position = getPosition();
this.tileSource = tileSource;
tileController.setTileSource(tileSource);
zoomSlider.setMinimum(tileSource.getMinZoom());
zoomSlider.setMaximum(tileSource.getMaxZoom());
tileController.cancelOutstandingJobs();
if (zoom > tileSource.getMaxZoom()) {
setZoom(tileSource.getMaxZoom());
}
attribution.initialize(tileSource);
setDisplayPosition(position, zoom);
repaint();
}
@Override
public void tileLoadingFinished(Tile tile, boolean success) {
tile.setLoaded(success);
repaint();
}
public boolean isMapRectanglesVisible() {
return mapRectanglesVisible;
}
/**
* Enables or disables painting of the {@link MapRectangle}
*
* @param mapRectanglesVisible {@code true} to enable painting of rectangles
* @see #addMapRectangle(MapRectangle)
* @see #getMapRectangleList()
*/
public void setMapRectanglesVisible(boolean mapRectanglesVisible) {
this.mapRectanglesVisible = mapRectanglesVisible;
repaint();
}
public boolean isMapPolygonsVisible() {
return mapPolygonsVisible;
}
/**
* Enables or disables painting of the {@link MapPolygon}
*
* @param mapPolygonsVisible {@code true} to enable painting of polygons
* @see #addMapPolygon(MapPolygon)
* @see #getMapPolygonList()
*/
public void setMapPolygonsVisible(boolean mapPolygonsVisible) {
this.mapPolygonsVisible = mapPolygonsVisible;
repaint();
}
public boolean isScrollWrapEnabled() {
return scrollWrapEnabled;
}
public void setScrollWrapEnabled(boolean scrollWrapEnabled) {
this.scrollWrapEnabled = scrollWrapEnabled;
repaint();
}
public ZOOM_BUTTON_STYLE getZoomButtonStyle() {
return zoomButtonStyle;
}
public void setZoomButtonStyle(ZOOM_BUTTON_STYLE style) {
zoomButtonStyle = style;
if (zoomSlider == null || zoomInButton == null || zoomOutButton == null) {
return;
}
switch (style) {
case HORIZONTAL:
zoomSlider.setBounds(10, 10, 30, 150);
zoomInButton.setBounds(4, 155, 18, 18);
zoomOutButton.setBounds(26, 155, 18, 18);
break;
case VERTICAL:
zoomSlider.setBounds(10, 27, 30, 150);
zoomInButton.setBounds(14, 8, 20, 20);
zoomOutButton.setBounds(14, 176, 20, 20);
break;
default:
zoomSlider.setBounds(10, 10, 30, 150);
zoomInButton.setBounds(4, 155, 18, 18);
zoomOutButton.setBounds(26, 155, 18, 18);
break;
}
repaint();
}
public TileController getTileController() {
return tileController;
}
/**
* Return tile information caching class
* @return tile cache
* @see TileController#getTileCache()
*/
public TileCache getTileCache() {
return tileController.getTileCache();
}
public void setTileLoader(TileLoader loader) {
tileController.setTileLoader(loader);
}
public AttributionSupport getAttribution() {
return attribution;
}
/**
* @param listener listener to set
*/
public void addJMVListener(JMapViewerEventListener listener) {
evtListenerList.add(JMapViewerEventListener.class, listener);
}
/**
* @param listener listener to remove
*/
public void removeJMVListener(JMapViewerEventListener listener) {
evtListenerList.remove(JMapViewerEventListener.class, listener);
}
/**
* Send an update to all objects registered with viewer
*
* @param evt event to dispatch
*/
private void fireJMVEvent(JMVCommandEvent evt) {
Object[] listeners = evtListenerList.getListenerList();
for (int i = 0; i < listeners.length; i += 2) {
if (listeners[i] == JMapViewerEventListener.class) {
((JMapViewerEventListener) listeners[i + 1]).processCommand(evt);
}
}
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/OsmTileLoader.java 0000644 0000000 0000000 00000014130 12641052742 025057 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import org.openstreetmap.gui.jmapviewer.interfaces.TileJob;
import org.openstreetmap.gui.jmapviewer.interfaces.TileLoader;
import org.openstreetmap.gui.jmapviewer.interfaces.TileLoaderListener;
/**
* A {@link TileLoader} implementation that loads tiles from OSM.
*
* @author Jan Peter Stotz
*/
public class OsmTileLoader implements TileLoader {
private static final Executor jobDispatcher = Executors.newSingleThreadExecutor();
private final class OsmTileJob implements TileJob {
private final Tile tile;
private InputStream input;
private boolean force;
private OsmTileJob(Tile tile) {
this.tile = tile;
}
@Override
public void run() {
synchronized (tile) {
if ((tile.isLoaded() && !tile.hasError()) || tile.isLoading())
return;
tile.loaded = false;
tile.error = false;
tile.loading = true;
}
try {
URLConnection conn = loadTileFromOsm(tile);
if (force) {
conn.setUseCaches(false);
}
loadTileMetadata(tile, conn);
if ("no-tile".equals(tile.getValue("tile-info"))) {
tile.setError("No tile at this zoom level");
} else {
input = conn.getInputStream();
try {
tile.loadImage(input);
} finally {
input.close();
input = null;
}
}
tile.setLoaded(true);
listener.tileLoadingFinished(tile, true);
} catch (Exception e) {
tile.setError(e.getMessage());
listener.tileLoadingFinished(tile, false);
if (input == null) {
try {
System.err.println("Failed loading " + tile.getUrl() +": "
+e.getClass() + ": " + e.getMessage());
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
} finally {
tile.loading = false;
tile.setLoaded(true);
}
}
@Override
public Tile getTile() {
return tile;
}
@Override
public void submit() {
submit(false);
}
@Override
public void submit(boolean force) {
this.force = force;
jobDispatcher.execute(this);
}
}
/**
* Holds the HTTP headers. Insert e.g. User-Agent here when default should not be used.
*/
public Map headers = new HashMap<>();
public int timeoutConnect;
public int timeoutRead;
protected TileLoaderListener listener;
public OsmTileLoader(TileLoaderListener listener) {
this(listener, null);
}
public OsmTileLoader(TileLoaderListener listener, Map headers) {
this.headers.put("Accept", "text/html, image/png, image/jpeg, image/gif, */*");
if (headers != null) {
this.headers.putAll(headers);
}
this.listener = listener;
}
@Override
public TileJob createTileLoaderJob(final Tile tile) {
return new OsmTileJob(tile);
}
protected URLConnection loadTileFromOsm(Tile tile) throws IOException {
URL url;
url = new URL(tile.getUrl());
URLConnection urlConn = url.openConnection();
if (urlConn instanceof HttpURLConnection) {
prepareHttpUrlConnection((HttpURLConnection) urlConn);
}
return urlConn;
}
protected void loadTileMetadata(Tile tile, URLConnection urlConn) {
String str = urlConn.getHeaderField("X-VE-TILEMETA-CaptureDatesRange");
if (str != null) {
tile.putValue("capture-date", str);
}
str = urlConn.getHeaderField("X-VE-Tile-Info");
if (str != null) {
tile.putValue("tile-info", str);
}
Long lng = urlConn.getExpiration();
if (lng.equals(0L)) {
try {
str = urlConn.getHeaderField("Cache-Control");
if (str != null) {
for (String token: str.split(",")) {
if (token.startsWith("max-age=")) {
lng = Long.parseLong(token.substring(8)) * 1000 +
System.currentTimeMillis();
}
}
}
} catch (NumberFormatException e) {
// ignore malformed Cache-Control headers
if (JMapViewer.debug) {
System.err.println(e.getMessage());
}
}
}
if (!lng.equals(0L)) {
tile.putValue("expires", lng.toString());
}
}
protected void prepareHttpUrlConnection(HttpURLConnection urlConn) {
for (Entry e : headers.entrySet()) {
urlConn.setRequestProperty(e.getKey(), e.getValue());
}
if (timeoutConnect != 0)
urlConn.setConnectTimeout(timeoutConnect);
if (timeoutRead != 0)
urlConn.setReadTimeout(timeoutRead);
}
@Override
public String toString() {
return getClass().getSimpleName();
}
@Override
public void cancelOutstandingTasks() {
// intentionally left empty - OsmTileLoader doesn't maintain queue
}
}
jmapviewer-1.14/src/org/openstreetmap/gui/jmapviewer/TileXY.java 0000644 0000000 0000000 00000002267 12566160406 023545 0 ustar root root // License: GPL. For details, see Readme.txt file.
package org.openstreetmap.gui.jmapviewer;
/**
* @author w
*
*/
public class TileXY {
/**
* x index of the tile (horizontal)
*/
private final double x;
/**
* y number of the tile (vertical)
*/
private final double y;
/**
* Returns an instance of coordinates.
*
* @param d number of the tile
* @param e number of the tile
*/
public TileXY(double d, double e) {
this.x = d;
this.y = e;
}
/**
* @return x index of the tile as integer
*/
public int getXIndex() {
return x < 0 ? (int) Math.ceil(x) : (int) Math.floor(x);
}
/**
* @return y index of the tile as integer
*/
public int getYIndex() {
return y < 0 ? (int) Math.ceil(y) : (int) Math.floor(y);
}
/**
* @return x index as double, might be non integral, when the point is not topleft corner of the tile
*/
public double getX() {
return x;
}
/**
* @return y index as double, might be non integral, when the point is not topleft corner of the tile
*/
public double getY() {
return y;
}
}