public int countImagesInSector(Sector sector, int levelNumber) {
if (sector == null) {
String msg = Logging.getMessage("nullValue.SectorIsNull");
Logging.logger().severe(msg);
throw new IllegalArgumentException(msg);
}
Level targetLevel = this.levels.getLastLevel();
if (levelNumber >= 0) {
for (int i = levelNumber; i < this.getLevels().getLastLevel().getLevelNumber(); i++) {
if (this.levels.isLevelEmpty(i)) continue;
targetLevel = this.levels.getLevel(i);
break;
}
}
// Collect all the tiles intersecting the input sector.
LatLon delta = targetLevel.getTileDelta();
Angle latOrigin = this.levels.getTileOrigin().getLatitude();
Angle lonOrigin = this.levels.getTileOrigin().getLongitude();
final int nwRow = Tile.computeRow(delta.getLatitude(), sector.getMaxLatitude(), latOrigin);
final int nwCol = Tile.computeColumn(delta.getLongitude(), sector.getMinLongitude(), lonOrigin);
final int seRow = Tile.computeRow(delta.getLatitude(), sector.getMinLatitude(), latOrigin);
final int seCol = Tile.computeColumn(delta.getLongitude(), sector.getMaxLongitude(), lonOrigin);
int numRows = nwRow - seRow + 1;
int numCols = seCol - nwCol + 1;
return numRows * numCols;
}
protected static boolean isTileVisible(
DrawContext dc, Tile tile, double minDistanceSquared, double maxDistanceSquared) {
if (!tile.getSector().intersects(dc.getVisibleSector())) return false;
View view = dc.getView();
Position eyePos = view.getEyePosition();
if (eyePos == null) return false;
Angle lat =
clampAngle(
eyePos.getLatitude(),
tile.getSector().getMinLatitude(),
tile.getSector().getMaxLatitude());
Angle lon =
clampAngle(
eyePos.getLongitude(),
tile.getSector().getMinLongitude(),
tile.getSector().getMaxLongitude());
Vec4 p = dc.getGlobe().computePointFromPosition(lat, lon, 0d);
double distSquared = dc.getView().getEyePoint().distanceToSquared3(p);
//noinspection RedundantIfStatement
if (minDistanceSquared > distSquared || maxDistanceSquared < distSquared) return false;
return true;
}
protected boolean loadTile(Tile tile, java.net.URL url) {
if (WWIO.isFileOutOfDate(url, this.placeNameServiceSet.getExpiryTime())) {
// The file has expired. Delete it then request download of newer.
this.getDataFileStore().removeFile(url);
String message = Logging.getMessage("generic.DataFileExpired", url);
Logging.logger().fine(message);
return false;
}
PlaceNameChunk tileData;
synchronized (this.fileLock) {
tileData = readTileData(tile, url);
}
if (tileData == null) {
// Assume that something's wrong with the file and delete it.
this.getDataFileStore().removeFile(url);
tile.getPlaceNameService()
.markResourceAbsent(tile.getPlaceNameService().getTileNumber(tile.row, tile.column));
String message = Logging.getMessage("generic.DeletedCorruptDataFile", url);
Logging.logger().fine(message);
return false;
}
tile.setDataChunk(tileData);
WorldWind.getMemoryCache(Tile.class.getName()).add(tile.getFileCachePath(), tile);
return true;
}
/**
* Base tick method for the level. Updates all entities, tiles, and player. Has slow repopulation
* algorithm
*/
public void tick() {
player.tick();
List<Entity> toTick = new ArrayList<Entity>();
int lr = 7;
for (int x = -lr; x < lr; x++) {
for (int y = -lr; y < lr; y++) {
Tile tile = getTile(player.x + x, player.z + y);
tile.addToTick(toTick);
tile.tick();
}
}
for (int i = 0; i < toTick.size(); i++) {
Entity e = toTick.get(i);
e.tick(this);
}
tickcount++;
if (tickcount % 1800 == 0) {
System.out.println("Adding entity to world");
if (r != null) {
int rx = r.nextInt(w);
int ry = r.nextInt(h);
if (skillNoise.noise(rx / 80d, ry / 80d) > 0.0) {
SmallMob mob = new SmallMob();
if (!tiles[rx + ry * w].blocks(mob)) {
tiles[rx + ry * w].addEntity(r.nextInt(4), mob);
}
}
}
}
}
public void mouseClicked(MouseEvent e) {
Tile t = (Tile) e.getSource();
ImageIcon temp = (ImageIcon) t.getIcon();
currTileImg = new ImageIcon(scaleImage(temp.getImage(), DISPLAY_SCALE));
currTileDisplay.setIcon(new ImageIcon(scaleImage(temp.getImage(), DISPLAY_SCALE * 2)));
currTileLoc = t.getSource();
}
/**
* Loads the tileset defined in the constructor into a JPanel which it then returns. Makes no
* assumptions about height or width, which means it needs to read an extra 64 tiles at worst (32
* down to check height and 32 across for width), since the maximum height/width is 32 tiles.
*/
public JPanel loadTileset() {
int height = MAX_TILESET_SIZE;
int width = MAX_TILESET_SIZE;
boolean maxHeight = false;
boolean maxWidth = false;
// find width
int j = 0;
while (!maxWidth) {
try {
File f = new File(tileDir + "/" + j + "_" + 0 + ".png");
ImageIO.read(f);
} catch (IOException e) {
width = j;
maxWidth = true;
}
j += TILE_SIZE;
}
// find height
int i = 0;
while (!maxHeight) {
try {
File f = new File(tileDir + "/" + 0 + "_" + i + ".png");
ImageIO.read(f);
} catch (IOException e) {
height = i;
maxHeight = true;
}
i += TILE_SIZE;
}
JPanel tileDisplay = new JPanel();
tileDisplay.setLayout(new GridLayout(height / TILE_SIZE, width / TILE_SIZE));
tileDisplay.setMinimumSize(new Dimension(width, height));
tileDisplay.setPreferredSize(new Dimension(width, height));
tileDisplay.setMaximumSize(new Dimension(width, height));
for (i = 0; i < height; i += TILE_SIZE) {
for (j = 0; j < width; j += TILE_SIZE) {
String fPath = tileDir + "/" + j + "_" + i;
try {
int[] mov = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
Image icon = getTile(tileDir, j, i, 1);
Tile tile =
new Tile(new ImageIcon(icon), "palette", 0, 0, mov, "none", false, "" + j + "_" + i);
tile.addMouseListener(new PaletteButtonListener());
tile.setMaximumSize(new Dimension(TILE_SIZE, TILE_SIZE));
tile.setPreferredSize(new Dimension(TILE_SIZE, TILE_SIZE));
tile.setMinimumSize(new Dimension(TILE_SIZE, TILE_SIZE));
tileDisplay.add(tile);
} catch (IOException e) {
}
}
}
return tileDisplay;
}
protected void requestTile(DrawContext dc, Tile tile) {
Vec4 centroid = dc.getGlobe().computePointFromPosition(tile.getSector().getCentroid(), 0);
if (this.getReferencePoint() != null)
tile.setPriority(centroid.distanceTo3(this.getReferencePoint()));
RequestTask task = new RequestTask(tile, this);
this.getRequestQ().add(task);
}
public Map loadMap(File input) throws FileNotFoundException {
Scanner s = new Scanner(input);
tileDir = s.nextLine();
int width = s.nextInt();
int height = s.nextInt();
Map toReturn = new Map(width, height, tileDir);
s.nextLine(); // eat up rest of line.
for (int y = 0; y < height; y++) {
String line = s.nextLine();
Scanner lineReader = new Scanner(line);
List<Tile> tList = new ArrayList<Tile>();
for (int x = 0; x < width; x++) {
String[] values = lineReader.next().split("/");
String name = values[0];
int[] picLocation = new int[2];
for (int i = 0; i < picLocation.length; i++) {
picLocation[i] = Integer.parseInt(values[1].split("_")[i]);
}
ImageIcon img = null;
try {
img = new ImageIcon(getTile(tileDir, picLocation[0], picLocation[1], DISPLAY_SCALE));
} catch (IOException e) {
System.out.println("Could not find image.");
img =
new ImageIcon(
new BufferedImage(
TILE_SIZE * DISPLAY_SCALE,
TILE_SIZE * DISPLAY_SCALE,
BufferedImage.TYPE_INT_RGB));
}
int avoid = Integer.parseInt(values[2]);
int def = Integer.parseInt(values[3]);
String[] movString = values[4].split(",");
int[] moveCost = new int[movString.length];
for (int i = 0; i < moveCost.length; i++) {
moveCost[i] = Integer.parseInt(movString[i]);
}
String special = values[5];
Tile t =
new Tile(
img,
name,
avoid,
def,
moveCost,
special,
true,
"" + picLocation[0] + "_" + picLocation[1]);
tList.add(t);
t.setMaximumSize(new Dimension(TILE_SIZE * DISPLAY_SCALE, TILE_SIZE * DISPLAY_SCALE));
t.setPreferredSize(new Dimension(TILE_SIZE * DISPLAY_SCALE, TILE_SIZE * DISPLAY_SCALE));
t.addMouseListener(new MapButtonListener());
}
toReturn.addRow(tList);
}
return toReturn;
}
public Tile getTile(int x, int y) {
if (x < 0 || y < 0 || x >= w || y >= h) {
waterTile.x = x;
waterTile.y = y;
return waterTile;
}
return tiles[x + y * w];
}
/**
* Triggers all tiles with the specified ID
*
* @param id The tile ID to trigger
* @param pressed True when the button is down
*/
public void trigger(int id, boolean pressed) {
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
Tile b = tiles[x + y * w];
if (b.id == id) {
b.trigger(pressed);
}
}
}
}
public void actionPerformed(ActionEvent e) {
for (int x = 0; x < mapWidth; x++) {
for (int y = 0; y < mapHeight; y++) {
Tile t = backEnd.getTile(x, y);
t.setIcon(new ImageIcon(scaleImage(currTileImg.getImage(), DISPLAY_SCALE)));
// System.out.println("fillButton actionListener");
t.setSource(currTileLoc);
}
}
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
final Tile tile = (Tile) o;
return !(this.getFileCachePath() != null
? !this.getFileCachePath().equals(tile.getFileCachePath())
: tile.getFileCachePath() != null);
}
private Tile getSpecialTile(int x, int y, int val) {
Tile tile = EmptyTile.instance;
if (layer == 0) {
tile = new Tile(Walls.grass);
Switch sw = new Switch(0, val);
sw.setPosition(0.2, 0.4, 0.9);
tile.addEntity(-1, sw);
}
if (layer == -1) {
tile = new Tile(Walls.dungeonFloor);
Switch sw = new Switch(0, val);
sw.setPosition(0.5, 0.4, 0.9);
tile.addEntity(-1, sw);
}
return tile;
}
public static void loadMap(int layer, Player player, RandomAccessFile loadfile)
throws IOException {
Level level =
new Level(Art.load("/res/map/layer_" + layer + ".png"), null, player, layer, true);
for (int x = 0; x < level.w; x++) {
for (int y = 0; y < level.h; y++) {
if (x == 0 && y == 0) {
System.out.printf("Entering first tile at %d!\n", loadfile.getFilePointer());
}
Tile tileToSave = level.getTile(x, y);
tileToSave.loadTile(loadfile);
}
}
level.init();
loadedMaps.put(layer, level);
}
public void run() {
if (this.tile.isTileInMemoryWithData()) return;
final java.net.URL tileURL =
this.layer.getDataFileStore().findFile(tile.getFileCachePath(), false);
if (tileURL != null) {
if (this.layer.loadTile(this.tile, tileURL)) {
tile.getPlaceNameService()
.unmarkResourceAbsent(
tile.getPlaceNameService().getTileNumber(tile.row, tile.column));
this.layer.firePropertyChange(AVKey.LAYER, null, this);
return;
}
}
this.layer.downloadTile(this.tile);
}
public void saveMap(int layer, RandomAccessFile savefile) throws IOException {
System.out.printf("Saving map %d at %d!\n", layer, savefile.getFilePointer());
Level level = loadedMaps.get(layer);
if (level == null) {
return;
}
savefile.writeInt(layer);
for (int x = 0; x < level.w; x++) {
for (int y = 0; y < level.h; y++) {
if (x == 0 && y == 0) {
System.out.printf("Entering first tile at %d!\n", savefile.getFilePointer());
}
Tile tileToSave = level.getTile(x, y);
tileToSave.saveTile(savefile);
}
}
}
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
final RequestTask that = (RequestTask) o;
// Don't include layer in comparison so that requests are shared among layers
return !(tile != null ? !tile.equals(that.tile) : that.tile != null);
}
/**
* Returns a map with the specified dimensions filled with the currTile image. The image should be
* the upper-left tile of a given tileset if this is called from the constructor.
*/
public Map emptyMap(int width, int height) {
Map toReturn = new Map(width, height, tileDir);
int[] mov = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
for (int i = 0; i < height; i++) {
List<Tile> tList = new ArrayList<Tile>();
for (int j = 0; j < width; j++) {
Tile t = new Tile(currTileImg, "Test", 0, 0, mov, "none", true, currTileLoc);
tList.add(t);
// t.setMargin(new Insets(0,0,0,0));
t.setMaximumSize(new Dimension(TILE_SIZE * DISPLAY_SCALE, TILE_SIZE * DISPLAY_SCALE));
t.setPreferredSize(new Dimension(TILE_SIZE * DISPLAY_SCALE, TILE_SIZE * DISPLAY_SCALE));
// tile.setPreferredSize(new Dimension(TILE_SIZE*DISPLAY_SCALE, TILE_SIZE*DISPLAY_SCALE));
t.addMouseListener(new MapButtonListener());
}
toReturn.addRow(tList);
}
return toReturn;
}
private MercatorTextureTile[][] getTilesInSector(Sector sector, int levelNumber) {
if (sector == null) {
String msg = Logging.getMessage("nullValue.SectorIsNull");
Logging.logger().severe(msg);
throw new IllegalArgumentException(msg);
}
Level targetLevel = this.levels.getLastLevel();
if (levelNumber >= 0) {
for (int i = levelNumber; i < this.getLevels().getLastLevel().getLevelNumber(); i++) {
if (this.levels.isLevelEmpty(i)) continue;
targetLevel = this.levels.getLevel(i);
break;
}
}
// Collect all the tiles intersecting the input sector.
LatLon delta = targetLevel.getTileDelta();
Angle latOrigin = this.levels.getTileOrigin().getLatitude();
Angle lonOrigin = this.levels.getTileOrigin().getLongitude();
final int nwRow = Tile.computeRow(delta.getLatitude(), sector.getMaxLatitude(), latOrigin);
final int nwCol = Tile.computeColumn(delta.getLongitude(), sector.getMinLongitude(), lonOrigin);
final int seRow = Tile.computeRow(delta.getLatitude(), sector.getMinLatitude(), latOrigin);
final int seCol = Tile.computeColumn(delta.getLongitude(), sector.getMaxLongitude(), lonOrigin);
int numRows = nwRow - seRow + 1;
int numCols = seCol - nwCol + 1;
MercatorTextureTile[][] sectorTiles = new MercatorTextureTile[numRows][numCols];
for (int row = nwRow; row >= seRow; row--) {
for (int col = nwCol; col <= seCol; col++) {
TileKey key =
new TileKey(targetLevel.getLevelNumber(), row, col, targetLevel.getCacheName());
Sector tileSector = this.levels.computeSectorForKey(key);
MercatorSector mSector = MercatorSector.fromSector(tileSector); // TODO: check
sectorTiles[nwRow - row][col - nwCol] =
new MercatorTextureTile(mSector, targetLevel, row, col);
}
}
return sectorTiles;
}
public List<Tile> getTiles() {
if (tileKeys.isEmpty()) {
Tile[] tiles = buildTiles(this.placeNameService, this);
// load tileKeys
for (Tile t : tiles) {
tileKeys.add(t.getFileCachePath());
WorldWind.getMemoryCache(Tile.class.getName()).add(t.getFileCachePath(), t);
}
return Arrays.asList(tiles);
} else {
List<Tile> dataTiles = new ArrayList<Tile>();
for (String s : tileKeys) {
Tile t = (Tile) WorldWind.getMemoryCache(Tile.class.getName()).getObject(s);
if (t != null) {
dataTiles.add(t);
}
}
return dataTiles;
}
}
private void createTopLevelTiles() {
MercatorSector sector = (MercatorSector) this.levels.getSector();
Level level = levels.getFirstLevel();
Angle dLat = level.getTileDelta().getLatitude();
Angle dLon = level.getTileDelta().getLongitude();
Angle latOrigin = this.levels.getTileOrigin().getLatitude();
Angle lonOrigin = this.levels.getTileOrigin().getLongitude();
// Determine the row and column offset from the common World Wind global tiling origin.
int firstRow = Tile.computeRow(dLat, sector.getMinLatitude(), latOrigin);
int firstCol = Tile.computeColumn(dLon, sector.getMinLongitude(), lonOrigin);
int lastRow = Tile.computeRow(dLat, sector.getMaxLatitude(), latOrigin);
int lastCol = Tile.computeColumn(dLon, sector.getMaxLongitude(), lonOrigin);
int nLatTiles = lastRow - firstRow + 1;
int nLonTiles = lastCol - firstCol + 1;
this.topLevels = new ArrayList<MercatorTextureTile>(nLatTiles * nLonTiles);
// Angle p1 = Tile.computeRowLatitude(firstRow, dLat);
double deltaLat = dLat.degrees / 90;
double d1 = -1.0 + deltaLat * firstRow;
for (int row = firstRow; row <= lastRow; row++) {
// Angle p2;
// p2 = p1.add(dLat);
double d2 = d1 + deltaLat;
Angle t1 = Tile.computeColumnLongitude(firstCol, dLon, lonOrigin);
for (int col = firstCol; col <= lastCol; col++) {
Angle t2;
t2 = t1.add(dLon);
this.topLevels.add(
new MercatorTextureTile(new MercatorSector(d1, d2, t1, t2), level, row, col));
t1 = t2;
}
d1 = d2;
}
}
protected void downloadTile(final Tile tile, DownloadPostProcessor postProcessor) {
if (!this.isNetworkRetrievalEnabled()) return;
if (!WorldWind.getRetrievalService().isAvailable()) return;
java.net.URL url;
try {
url = tile.getRequestURL();
if (WorldWind.getNetworkStatus().isHostUnavailable(url)) return;
} catch (java.net.MalformedURLException e) {
Logging.logger()
.log(
java.util.logging.Level.SEVERE,
Logging.getMessage("layers.PlaceNameLayer.ExceptionCreatingUrl", tile),
e);
return;
}
Retriever retriever;
if ("http".equalsIgnoreCase(url.getProtocol()) || "https".equalsIgnoreCase(url.getProtocol())) {
if (postProcessor == null) postProcessor = new DownloadPostProcessor(this, tile);
retriever = new HTTPRetriever(url, postProcessor);
} else {
Logging.logger()
.severe(
Logging.getMessage("layers.PlaceNameLayer.UnknownRetrievalProtocol", url.toString()));
return;
}
// Apply any overridden timeouts.
Integer cto = AVListImpl.getIntegerValue(this, AVKey.URL_CONNECT_TIMEOUT);
if (cto != null && cto > 0) retriever.setConnectTimeout(cto);
Integer cro = AVListImpl.getIntegerValue(this, AVKey.URL_READ_TIMEOUT);
if (cro != null && cro > 0) retriever.setReadTimeout(cro);
Integer srl = AVListImpl.getIntegerValue(this, AVKey.RETRIEVAL_QUEUE_STALE_REQUEST_LIMIT);
if (srl != null && srl > 0) retriever.setStaleRequestLimit(srl);
WorldWind.getRetrievalService().runRetriever(retriever, tile.getPriority());
}
protected Tile[] buildTiles(PlaceNameService placeNameService, NavigationTile navTile) {
final Angle dLat = placeNameService.getTileDelta().getLatitude();
final Angle dLon = placeNameService.getTileDelta().getLongitude();
// Determine the row and column offset from the global tiling origin for the southwest tile
// corner
int firstRow = Tile.computeRow(dLat, navTile.navSector.getMinLatitude());
int firstCol = Tile.computeColumn(dLon, navTile.navSector.getMinLongitude());
int lastRow = Tile.computeRow(dLat, navTile.navSector.getMaxLatitude().subtract(dLat));
int lastCol = Tile.computeColumn(dLon, navTile.navSector.getMaxLongitude().subtract(dLon));
int nLatTiles = lastRow - firstRow + 1;
int nLonTiles = lastCol - firstCol + 1;
Tile[] tiles = new Tile[nLatTiles * nLonTiles];
Angle p1 = Tile.computeRowLatitude(firstRow, dLat);
for (int row = 0; row <= lastRow - firstRow; row++) {
Angle p2;
p2 = p1.add(dLat);
Angle t1 = Tile.computeColumnLongitude(firstCol, dLon);
for (int col = 0; col <= lastCol - firstCol; col++) {
Angle t2;
t2 = t1.add(dLon);
// Need offset row and column to correspond to total ro/col numbering
tiles[col + row * nLonTiles] =
new Tile(placeNameService, new Sector(p1, p2, t1, t2), row + firstRow, col + firstCol);
t1 = t2;
}
p1 = p2;
}
return tiles;
}
protected void drawOrRequestTile(
DrawContext dc,
Tile tile,
double minDisplayDistanceSquared,
double maxDisplayDistanceSquared) {
if (!isTileVisible(dc, tile, minDisplayDistanceSquared, maxDisplayDistanceSquared)) return;
if (tile.isTileInMemoryWithData()) {
PlaceNameChunk placeNameChunk = tile.getDataChunk();
if (placeNameChunk.numEntries > 0) {
Iterable<GeographicText> renderIter = placeNameChunk.makeIterable(dc);
this.placeNameRenderer.render(dc, renderIter);
}
return;
}
// Tile's data isn't available, so request it
if (!tile.getPlaceNameService()
.isResourceAbsent(tile.getPlaceNameService().getTileNumber(tile.row, tile.column))) {
this.requestTile(dc, tile);
}
}
public URL getURL(Tile tile, String altImageFormat) throws MalformedURLException {
StringBuffer sb;
if (this.URLTemplate == null) {
sb = new StringBuffer(WWXML.fixGetMapString(tile.getLevel().getService()));
if (!sb.toString().toLowerCase().contains("service=wms")) sb.append("service=WMS");
sb.append("&request=GetMap");
sb.append("&version=").append(this.wmsVersion);
sb.append(this.crs);
sb.append("&layers=").append(this.layerNames);
sb.append("&styles=").append(this.styleNames != null ? this.styleNames : "");
sb.append("&transparent=TRUE");
if (this.backgroundColor != null) sb.append("&bgcolor=").append(this.backgroundColor);
this.URLTemplate = sb.toString();
} else {
sb = new StringBuffer(this.URLTemplate);
}
String format = (altImageFormat != null) ? altImageFormat : this.imageFormat;
if (null != format) sb.append("&format=").append(format);
sb.append("&width=").append(tile.getWidth());
sb.append("&height=").append(tile.getHeight());
Sector s = tile.getSector();
sb.append("&bbox=");
sb.append(s.getMinLongitude().getDegrees());
sb.append(",");
sb.append(s.getMinLatitude().getDegrees());
sb.append(",");
sb.append(s.getMaxLongitude().getDegrees());
sb.append(",");
sb.append(s.getMaxLatitude().getDegrees());
// sb.append("&"); // terminate the query string
return new java.net.URL(sb.toString().replace(" ", "%20"));
}
protected static PlaceNameChunk readTileData(Tile tile, java.net.URL url) {
java.io.InputStream is = null;
try {
String path = url.getFile();
path =
path.replaceAll(
"%20", " "); // TODO: find a better way to get a path usable by FileInputStream
java.io.FileInputStream fis = new java.io.FileInputStream(path);
java.io.BufferedInputStream buf = new java.io.BufferedInputStream(fis);
is = new java.util.zip.GZIPInputStream(buf);
GMLPlaceNameSAXHandler handler = new GMLPlaceNameSAXHandler();
javax.xml.parsers.SAXParserFactory.newInstance().newSAXParser().parse(is, handler);
return handler.createPlaceNameChunk(tile.getPlaceNameService());
} catch (Exception e) {
// todo log actual error
Logging.logger()
.log(
Level.FINE,
Logging.getMessage(
"layers.PlaceNameLayer.ExceptionAttemptingToReadFile", url.toString()),
e);
} finally {
try {
if (is != null) is.close();
} catch (java.io.IOException e) {
Logging.logger()
.log(
Level.FINE,
Logging.getMessage(
"layers.PlaceNameLayer.ExceptionAttemptingToReadFile", url.toString()),
e);
}
}
return null;
}
protected boolean isTileInMemoryWithData() {
Tile t =
(Tile) WorldWind.getMemoryCache(Tile.class.getName()).getObject(this.getFileCachePath());
return !(t == null || t.getDataChunk() == null);
}
public void actionPerformed(ActionEvent e) {
int tempW = mapWidth;
int tempH = mapHeight;
int targetW;
int targetH;
try {
targetW = Integer.parseInt(widthField.getText());
targetH = Integer.parseInt(heightField.getText());
if (targetH <= 0 || targetW <= 0) {
JOptionPane.showMessageDialog(null, "Both x and y must be above 0.");
} else {
// shrink width if necessary
while (targetW < mapWidth) {
for (int i = mapHeight * mapWidth - 1; i >= 0; i -= mapWidth) {
map.remove(i);
}
mapWidth--;
mapScroll.revalidate();
map.repaint();
backEnd.removeColumn(backEnd.getWidth() - 1);
}
// shrink height if necessary
while (targetH < mapHeight) {
for (int i = 1; i <= mapWidth; i++) {
map.remove(mapHeight * mapWidth - i);
}
mapHeight--;
// map.setLayout(new GridLayout(mapHeight,mapWidth));
map.repaint();
backEnd.removeRow(backEnd.getHeight() - 1);
}
// Grow if necessary
if (targetW > mapWidth || targetH > mapHeight) {
// add new rows and columns, then rebuild and re-add display
int[] mov = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
while (targetW > mapWidth) {
// add new column to backEnd
List<Tile> tList = new ArrayList<Tile>();
for (int i = 0; i < mapHeight; i++) {
Tile t = new Tile(currTileImg, "Test", 0, 0, mov, "none", true, currTileLoc);
t.setPreferredSize(
new Dimension(TILE_SIZE * DISPLAY_SCALE, TILE_SIZE * DISPLAY_SCALE));
t.addMouseListener(new MapButtonListener());
tList.add(t);
}
backEnd.addColumn(tList);
mapWidth++;
}
while (targetH > mapHeight) {
// add new row to backEnd
List<Tile> tList = new ArrayList<Tile>();
for (int i = 0; i < mapWidth; i++) {
Tile t = new Tile(currTileImg, "Test", 0, 0, mov, "none", true, currTileLoc);
t.setPreferredSize(
new Dimension(TILE_SIZE * DISPLAY_SCALE, TILE_SIZE * DISPLAY_SCALE));
t.addMouseListener(new MapButtonListener());
tList.add(t);
}
backEnd.addRow(tList);
mapHeight++;
}
GridBagConstraints gbc = new GridBagConstraints();
for (int i = 0; i < mapHeight; i++) {
gbc.gridy = i;
for (int j = 0; j < mapWidth; j++) {
gbc.gridx = j;
map.add(backEnd.getTile(j, i), gbc);
}
}
map.revalidate();
map.repaint();
parentPanel.revalidate();
parentPanel.repaint();
((MapBuilder) SwingUtilities.getWindowAncestor(parentPanel)).pack();
}
}
} catch (NumberFormatException f) {
JOptionPane.showMessageDialog(null, "Both x and y must be valid integers.");
}
}
public void mouseClicked(MouseEvent e) {
Tile t = (Tile) e.getSource();
t.setIcon(new ImageIcon(scaleImage(currTileImg.getImage(), 1)));
t.setSource(currTileLoc);
}
public int hashCode() {
return (tile != null ? tile.hashCode() : 0);
}
