openlayers
Version:
Build tools and sources for developing OpenLayers based mapping applications
176 lines (147 loc) • 4.21 kB
JavaScript
goog.provide('ol.Tile');
goog.require('ol');
goog.require('ol.events.EventTarget');
goog.require('ol.events.EventType');
/**
* @classdesc
* Base class for tiles.
*
* @constructor
* @extends {ol.events.EventTarget}
* @param {ol.TileCoord} tileCoord Tile coordinate.
* @param {ol.Tile.State} state State.
*/
ol.Tile = function(tileCoord, state) {
ol.events.EventTarget.call(this);
/**
* @type {ol.TileCoord}
*/
this.tileCoord = tileCoord;
/**
* @protected
* @type {ol.Tile.State}
*/
this.state = state;
/**
* An "interim" tile for this tile. The interim tile may be used while this
* one is loading, for "smooth" transitions when changing params/dimensions
* on the source.
* @type {ol.Tile}
*/
this.interimTile = null;
/**
* A key assigned to the tile. This is used by the tile source to determine
* if this tile can effectively be used, or if a new tile should be created
* and this one be used as an interim tile for this new tile.
* @type {string}
*/
this.key = '';
};
ol.inherits(ol.Tile, ol.events.EventTarget);
/**
* @protected
*/
ol.Tile.prototype.changed = function() {
this.dispatchEvent(ol.events.EventType.CHANGE);
};
/**
* Get the HTML image element for this tile (may be a Canvas, Image, or Video).
* @abstract
* @return {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} Image.
*/
ol.Tile.prototype.getImage = function() {};
/**
* @return {string} Key.
*/
ol.Tile.prototype.getKey = function() {
return this.key + '/' + this.tileCoord;
};
/**
* Get the interim tile most suitable for rendering using the chain of interim
* tiles. This corresponds to the most recent tile that has been loaded, if no
* such tile exists, the original tile is returned.
* @return {!ol.Tile} Best tile for rendering.
*/
ol.Tile.prototype.getInterimTile = function() {
if (!this.interimTile) {
//empty chain
return this;
}
var tile = this.interimTile;
// find the first loaded tile and return it. Since the chain is sorted in
// decreasing order of creation time, there is no need to search the remainder
// of the list (all those tiles correspond to older requests and will be
// cleaned up by refreshInterimChain)
do {
if (tile.getState() == ol.Tile.State.LOADED) {
return tile;
}
tile = tile.interimTile;
} while (tile);
// we can not find a better tile
return this;
};
/**
* Goes through the chain of interim tiles and discards sections of the chain
* that are no longer relevant.
*/
ol.Tile.prototype.refreshInterimChain = function() {
if (!this.interimTile) {
return;
}
var tile = this.interimTile;
var prev = this;
do {
if (tile.getState() == ol.Tile.State.LOADED) {
//we have a loaded tile, we can discard the rest of the list
//we would could abort any LOADING tile request
//older than this tile (i.e. any LOADING tile following this entry in the chain)
tile.interimTile = null;
break;
} else if (tile.getState() == ol.Tile.State.LOADING) {
//keep this LOADING tile any loaded tiles later in the chain are
//older than this tile, so we're still interested in the request
prev = tile;
} else if (tile.getState() == ol.Tile.State.IDLE) {
//the head of the list is the most current tile, we don't need
//to start any other requests for this chain
prev.interimTile = tile.interimTile;
} else {
prev = tile;
}
tile = prev.interimTile;
} while (tile);
};
/**
* Get the tile coordinate for this tile.
* @return {ol.TileCoord} The tile coordinate.
* @api
*/
ol.Tile.prototype.getTileCoord = function() {
return this.tileCoord;
};
/**
* @return {ol.Tile.State} State.
*/
ol.Tile.prototype.getState = function() {
return this.state;
};
/**
* Load the image or retry if loading previously failed.
* Loading is taken care of by the tile queue, and calling this method is
* only needed for preloading or for reloading in case of an error.
* @abstract
* @api
*/
ol.Tile.prototype.load = function() {};
/**
* @enum {number}
*/
ol.Tile.State = {
IDLE: 0,
LOADING: 1,
LOADED: 2,
ERROR: 3,
EMPTY: 4,
ABORT: 5
};