import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
public boolean isLoaded() {
	if (!mTilesPresent)
		return false;
	for (int i = 0; i < mTiles.length; i++) {
		Tile[] tiles = mTiles[i];
		for (int j = 0; j < tiles.length; j++) {
			Tile tile = tiles[j];
			if (!tile.isLoaded() && !tile.hasError()) {
				System.out.println("Tile " + tile + " is not loaded:"
						+ tile.getStatus());
				return false;
			}
		}
	}
	if (!mImageCreated) {
		createImage();
		mImageCreated = true;
	}
	return isDrawingDone();
}
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 * Is called when all tiles are loaded and creates the common picture.
 */
private void createImage() {
	BufferedImage tileImage00 = mTiles[0][0].getImage();
	int height = tileImage00.getHeight();
	int width = tileImage00.getWidth();
	mImage = new BufferedImage(height * mTiles[0].length, width
			* mTiles.length, BufferedImage.TYPE_INT_RGB);
	Graphics2D graphics = (Graphics2D) mImage.getGraphics();
	for (int i = 0; i < mTiles.length; i++) {
		Tile[] tiles = mTiles[i];
		for (int j = 0; j < tiles.length; j++) {
			Tile tile = tiles[j];
			boolean done = graphics.drawImage(tile.getImage(), i
					* height, j * width, this);
			if (!done) {
				mWaitingForCallbacks++;
			}
		}
	}
	if (isDrawingDone()) {
		drawCross();
	}
}
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 * @param pDimension
 * @param pX
 * @param pY
 * @param pZoom
 * @param mTileController
 * @param pLogger
 * @param pDy
 * @param pDx
 */
public void setTiles(int pDimension, int pX, int pY, int pZoom,
		TileController mTileController, Logger pLogger, int pDx, int pDy) {
	mDx = pDx;
	mDy = pDy;
	mTiles = new Tile[pDimension][pDimension];
	for (int i = 0; i < pDimension; ++i) {
		for (int j = 0; j < pDimension; ++j) {
			pLogger.fine("Trying to load tile to x=" + (pX + i)
					+ ", y=" + (pY + j) + ", zoom=" + pZoom);
			mTiles[i][j] = mTileController.getTile(pX + i, pY + j,
					pZoom);
		}
	}
	mTilesPresent = true;
}
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 * @return
 */
public boolean hasErrors() {
	if (!mTilesPresent)
		return false;
	for (int i = 0; i < mTiles.length; i++) {
		Tile[] tiles = mTiles[i];
		for (int j = 0; j < tiles.length; j++) {
			Tile tile = tiles[j];
			if (tile.hasError()) {
				return true;
			}
		}
	}
	return false;
}
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
@Override
public ICoordinate tileXYToLatLon(Tile tile) {
    return tileXYToLatLon(tile.getXtile(), tile.getYtile(), tile.getZoom());
}
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
@Override
public void tileLoadingFinished(Tile tile, boolean success) {
    tile.setLoaded(success);
    mapComponent.repaint();
}
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
@Override
public void draw(Graphics2D g2d, double scale, boolean drawSelectionState) {
    if (mapComponent == null) {
        return;
    }

    // compute OSM zoom level
    int zoom = zoomLevel(scale);
    if (zoom > OSM_MAX_ZOOM) {
        zoom = OSM_MAX_ZOOM;
    } else if (zoom < OSM_MIN_ZOOM) {
        zoom = OSM_MIN_ZOOM;
    }

    // compute number of tiles of the whole planet
    int tilesH = (int) Math.round(Math.pow(2, zoom));
    int tilesV = tilesH;
    double tileDim = BOUNDS.getWidth() / tilesH;

    // the first and last tiles visible in horizontal and vertical direction
    Rectangle2D.Double visRect = mapComponent.getVisibleArea();
    double visBottom = visRect.getMinY();
    double visLeft = visRect.getMinX();
    double visWidth = visRect.getWidth();
    double visHeight = visRect.getHeight();
    int firstRow = (int) ((BOUNDS.getMaxY() - (visBottom + visHeight)) / tileDim);
    firstRow = Math.max(firstRow, 0);
    int firstCol = (int) ((visLeft - BOUNDS.getMinX()) / tileDim);
    firstCol = Math.max(firstCol, 0);
    int lastRow = tilesV - (int) ((visBottom - BOUNDS.getMinY()) / tileDim);
    lastRow = Math.min(tilesV, lastRow);
    int lastCol = tilesH - (int) ((BOUNDS.getMaxX() - (visLeft + visWidth)) / tileDim);
    lastCol = Math.min(tilesH, lastCol);

    // load and draw all visible tiles
    for (int tiley = firstRow; tiley < lastRow; tiley++) {
        double y = BOUNDS.getMaxY() - tiley * tileDim;
        for (int tilex = firstCol; tilex < lastCol; tilex++) {
            double x = BOUNDS.getMinX() + tilex * tileDim;
            Tile tile = tileController.getTile(tilex, tiley, zoom);
            if (tile != null) {
                drawTile(tile.getImage(), g2d, x, y, tileDim, tileDim);
            }
        }
    }

    if (showGraticule) {
        drawGraticule(g2d);
    }

    // style for polar and tropic circles
    g2d.setColor(POLAR_TROPIC_COLOR);
    g2d.setStroke(new BasicStroke(0, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_OFF);

    if (showPolarCircles) {
        g2d.draw(new Line2D.Double(MAX_X, POLAR_CIRCLE_Y, -MAX_X, POLAR_CIRCLE_Y));
        g2d.draw(new Line2D.Double(MAX_X, -POLAR_CIRCLE_Y, -MAX_X, -POLAR_CIRCLE_Y));
    }

    if (showTropics) {
        g2d.draw(new Line2D.Double(MAX_X, TROPIC_CIRCLE_Y, -MAX_X, TROPIC_CIRCLE_Y));
        g2d.draw(new Line2D.Double(MAX_X, -TROPIC_CIRCLE_Y, -MAX_X, -TROPIC_CIRCLE_Y));
    }

    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);
}
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
private String getFileName(Tile tile)
{
    ICoordinate coord = tile.getSource().tileXYToLatLon(tile);
    return getFileName(coord.getLat(), coord.getLon(), tile.getZoom());
}
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
@Override
public void tileLoadingFinished(Tile tile, boolean success) {
       flushImage();
	viewer.repaint();
}
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 *
 * @param tile Tile
 * @return WGS84 coordinates of given tile
 */
ICoordinate tileXYToLatLon(Tile tile);
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 * 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);
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 * Retrieves a tile from the cache if present, otherwise <code>null</code>
 * 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 <code>null</code> if the tile is not
 *         present in the cache
 */
Tile getTile(TileSource source, int x, int y, int z);
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 * 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);
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 * 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);
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 * Function to return the tile associated with the job
 *
 * @return {@link Tile} to be handled
 */
Tile getTile();
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
public void tileLoadingFinished(Tile pTile, boolean pSuccess) {
	// TODO Auto-generated method stub

}
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 * Will be called if a new {@link Tile} has been loaded successfully.
 * Loaded can mean downloaded or loaded from file cache.
 *
 * @param tile
 */
public void tileLoadingFinished(Tile tile, boolean success);
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 * Retrieves a tile from the cache if present, otherwise <code>null</code>
 * 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 <code>null</code> if the tile is not
 *         present in the cache
 */
public Tile getTile(TileSource source, int x, int y, int z);
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 * 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
 */
public void addTile(Tile tile);
 

import org.openstreetmap.gui.jmapviewer.Tile; //导入依赖的package包/类
/**
 * 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.
 */
public TileJob createTileLoaderJob(Tile tile);