ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Redefine ol.Size to be Array.<number>

Browse Source
This commit is contained in:
Frederic Junod
2013-05-31 16:24:47 +02:00
parent 1d7ca27e61
commit a1a7e21f92
33 changed files with 139 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/ol/renderer/canvas/canvasimagelayerrenderer.js
View File

@@ -104,7 +104,7 @@ ol.renderer.canvas.ImageLayer.prototype.renderFrame =
var transform = this.transform_;
goog.vec.Mat4.makeIdentity(transform);
goog.vec.Mat4.translate(transform,
frameState.size.width / 2, frameState.size.height / 2, 0);
frameState.size[0] / 2, frameState.size[1] / 2, 0);
goog.vec.Mat4.rotateZ(transform, viewRotation);
goog.vec.Mat4.scale(
transform,

25
src/ol/renderer/canvas/canvasmaprenderer.js
View File

@@ -16,6 +16,7 @@ goog.require('ol.renderer.Map');
goog.require('ol.renderer.canvas.ImageLayer');
goog.require('ol.renderer.canvas.TileLayer');
goog.require('ol.renderer.canvas.VectorLayer');
goog.require('ol.size');
@@ -29,19 +30,13 @@ ol.renderer.canvas.Map = function(container, map) {
goog.base(this, container, map);
/**
* @private
* @type {ol.Size}
*/
this.canvasSize_ = new ol.Size(container.clientHeight, container.clientWidth);
/**
* @private
* @type {Element}
*/
this.canvas_ = goog.dom.createElement(goog.dom.TagName.CANVAS);
this.canvas_.height = this.canvasSize_.height;
this.canvas_.width = this.canvasSize_.width;
this.canvas_.height = container.clientHeight;
this.canvas_.width = container.clientWidth;
this.canvas_.className = ol.css.CLASS_UNSELECTABLE;
goog.dom.insertChildAt(container, this.canvas_, 0);
@@ -51,6 +46,12 @@ ol.renderer.canvas.Map = function(container, map) {
*/
this.renderedVisible_ = true;
/**
* @private
* @type {ol.Size}
*/
this.canvasSize_ = [container.clientHeight, container.clientWidth];
/**
* @private
* @type {CanvasRenderingContext2D}
@@ -100,15 +101,15 @@ ol.renderer.canvas.Map.prototype.renderFrame = function(frameState) {
}
var size = frameState.size;
if (!this.canvasSize_.equals(size)) {
this.canvas_.width = size.width;
this.canvas_.height = size.height;
if (!ol.size.equals(this.canvasSize_, size)) {
this.canvas_.width = size[0];
this.canvas_.height = size[1];
this.canvasSize_ = size;
}
var context = this.context_;
context.setTransform(1, 0, 0, 1, 0, 0);
context.clearRect(0, 0, size.width, size.height);
context.clearRect(0, 0, size[0], size[1]);
this.calculateMatrices2D(frameState);

39
src/ol/renderer/canvas/canvastilelayerrenderer.js
View File

@@ -195,8 +195,8 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
var tileRange = tileGrid.getTileRangeForExtentAndResolution(
extent, tileResolution);
var canvasWidth = tileSize.width * tileRange.getWidth();
var canvasHeight = tileSize.height * tileRange.getHeight();
var canvasWidth = tileSize[0] * tileRange.getWidth();
var canvasHeight = tileSize[1] * tileRange.getHeight();
var canvas, context;
if (goog.isNull(this.canvas_)) {
@@ -209,24 +209,23 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
canvas.height = canvasHeight;
context = /** @type {CanvasRenderingContext2D} */ (canvas.getContext('2d'));
this.canvas_ = canvas;
this.canvasSize_ = new ol.Size(canvasWidth, canvasHeight);
this.canvasSize_ = [canvasWidth, canvasHeight];
this.context_ = context;
} else {
goog.asserts.assert(!goog.isNull(this.canvasSize_));
goog.asserts.assert(!goog.isNull(this.context_));
canvas = this.canvas_;
context = this.context_;
if (this.canvasSize_.width < canvasWidth ||
this.canvasSize_.height < canvasHeight) {
if (this.canvasSize_[0] < canvasWidth ||
this.canvasSize_[1] < canvasHeight) {
// Canvas is too small, make it bigger
canvas.width = canvasWidth;
canvas.height = canvasHeight;
this.canvasSize_.width = canvasWidth;
this.canvasSize_.height = canvasHeight;
this.canvasSize_ = [canvasWidth, canvasHeight];
this.renderedCanvasTileRange_ = null;
} else {
canvasWidth = this.canvasSize_.width;
canvasHeight = this.canvasSize_.height;
canvasWidth = this.canvasSize_[0];
canvasHeight = this.canvasSize_[1];
if (z != this.renderedCanvasZ_ ||
!this.renderedCanvasTileRange_.containsTileRange(tileRange)) {
this.renderedCanvasTileRange_ = null;
@@ -236,8 +235,8 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
var canvasTileRange, canvasTileRangeWidth, minX, minY;
if (goog.isNull(this.renderedCanvasTileRange_)) {
canvasTileRangeWidth = canvasWidth / tileSize.width;
var canvasTileRangeHeight = canvasHeight / tileSize.height;
canvasTileRangeWidth = canvasWidth / tileSize[0];
var canvasTileRangeHeight = canvasHeight / tileSize[1];
minX = tileRange.minX -
Math.floor((canvasTileRangeWidth - tileRange.getWidth()) / 2);
minY = tileRange.minY -
@@ -304,9 +303,9 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
var i, ii;
for (i = 0, ii = tilesToClear.length; i < ii; ++i) {
tile = tilesToClear[i];
x = tileSize.width * (tile.tileCoord.x - canvasTileRange.minX);
y = tileSize.height * (canvasTileRange.maxY - tile.tileCoord.y);
context.clearRect(x, y, tileSize.width, tileSize.height);
x = tileSize[0] * (tile.tileCoord.x - canvasTileRange.minX);
y = tileSize[1] * (canvasTileRange.maxY - tile.tileCoord.y);
context.clearRect(x, y, tileSize[0], tileSize[1]);
}
/** @type {Array.<number>} */
@@ -330,13 +329,13 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
(tile.tileCoord.y - canvasTileRange.minY) * canvasTileRangeWidth +
(tile.tileCoord.x - canvasTileRange.minX);
if (this.renderedTiles_[index] != tile) {
x = tileSize.width * (tile.tileCoord.x - canvasTileRange.minX);
y = tileSize.height * (canvasTileRange.maxY - tile.tileCoord.y);
x = tileSize[0] * (tile.tileCoord.x - canvasTileRange.minX);
y = tileSize[1] * (canvasTileRange.maxY - tile.tileCoord.y);
tileState = tile.getState();
if (tileState == ol.TileState.EMPTY ||
tileState == ol.TileState.ERROR ||
!opaque) {
context.clearRect(x, y, tileSize.width, tileSize.height);
context.clearRect(x, y, tileSize[0], tileSize[1]);
}
if (tileState == ol.TileState.LOADED) {
context.drawImage(tile.getImage(), x, y);
@@ -351,8 +350,8 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
tileExtent = tileGrid.getTileCoordExtent(tile.tileCoord, tmpExtent);
x = (tileExtent[0] - origin[0]) / tileResolution;
y = (origin[1] - tileExtent[3]) / tileResolution;
width = scale * tileSize.width;
height = scale * tileSize.height;
width = scale * tileSize[0];
height = scale * tileSize[1];
tileState = tile.getState();
if (tileState == ol.TileState.EMPTY || !opaque) {
context.clearRect(x, y, width, height);
@@ -386,7 +385,7 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
var transform = this.transform_;
goog.vec.Mat4.makeIdentity(transform);
goog.vec.Mat4.translate(transform,
frameState.size.width / 2, frameState.size.height / 2, 0);
frameState.size[0] / 2, frameState.size[1] / 2, 0);
goog.vec.Mat4.rotateZ(transform, view2DState.rotation);
goog.vec.Mat4.scale(
transform,

36
src/ol/renderer/canvas/canvasvectorlayerrenderer.js
View File

@@ -7,7 +7,6 @@ goog.require('goog.events.EventType');
goog.require('goog.object');
goog.require('goog.vec.Mat4');
goog.require('ol.Pixel');
goog.require('ol.Size');
goog.require('ol.TileCache');
goog.require('ol.TileCoord');
goog.require('ol.ViewHint');
@@ -297,7 +296,7 @@ ol.renderer.canvas.VectorLayer.prototype.renderFrame =
tileGrid = ol.tilegrid.createForProjection(
view2DState.projection,
22, // should be no harm in going big here - ideally, it would be ∞
new ol.Size(512, 512));
[512, 512]);
this.tileGrid_ = tileGrid;
}
@@ -313,8 +312,8 @@ ol.renderer.canvas.VectorLayer.prototype.renderFrame =
goog.vec.Mat4.makeIdentity(transform);
goog.vec.Mat4.translate(transform,
frameState.size.width / 2,
frameState.size.height / 2,
frameState.size[0] / 2,
frameState.size[1] / 2,
0);
goog.vec.Mat4.scale(transform,
tileResolution / resolution, tileResolution / resolution, 1);
@@ -339,8 +338,8 @@ ol.renderer.canvas.VectorLayer.prototype.renderFrame =
if (goog.isNull(this.tileArchetype_)) {
this.tileArchetype_ = /** @type {HTMLCanvasElement} */
(goog.dom.createElement(goog.dom.TagName.CANVAS));
this.tileArchetype_.width = tileSize.width;
this.tileArchetype_.height = tileSize.height;
this.tileArchetype_.width = tileSize[0];
this.tileArchetype_.height = tileSize[1];
}
/**
@@ -348,14 +347,13 @@ ol.renderer.canvas.VectorLayer.prototype.renderFrame =
* and will have rendered all newly visible features.
*/
var sketchCanvas = this.sketchCanvas_;
var sketchSize = new ol.Size(
tileSize.width * tileRange.getWidth(),
tileSize.height * tileRange.getHeight());
var sketchWidth = tileSize[0] * tileRange.getWidth();
var sketchHeight = tileSize[1] * tileRange.getHeight();
// transform for map coords to sketch canvas pixel coords
var sketchTransform = this.sketchTransform_;
var halfWidth = sketchSize.width / 2;
var halfHeight = sketchSize.height / 2;
var halfWidth = sketchWidth / 2;
var halfHeight = sketchHeight / 2;
goog.vec.Mat4.makeIdentity(sketchTransform);
goog.vec.Mat4.translate(sketchTransform,
halfWidth,
@@ -371,16 +369,16 @@ ol.renderer.canvas.VectorLayer.prototype.renderFrame =
0);
// clear/resize sketch canvas
sketchCanvas.width = sketchSize.width;
sketchCanvas.height = sketchSize.height;
sketchCanvas.width = sketchWidth;
sketchCanvas.height = sketchHeight;
var sketchCanvasRenderer = new ol.renderer.canvas.VectorRenderer(
sketchCanvas, sketchTransform, undefined, this.requestMapRenderFrame_);
// clear/resize final canvas
var finalCanvas = this.canvas_;
finalCanvas.width = sketchSize.width;
finalCanvas.height = sketchSize.height;
finalCanvas.width = sketchWidth;
finalCanvas.height = sketchHeight;
var finalContext = this.context_;
var featuresToRender = {};
@@ -456,13 +454,13 @@ ol.renderer.canvas.VectorLayer.prototype.renderFrame =
tile = /** @type {HTMLCanvasElement} */
(this.tileArchetype_.cloneNode(false));
tile.getContext('2d').drawImage(sketchCanvas,
(tileRange.minX - tileCoord.x) * tileSize.width,
(tileCoord.y - tileRange.maxY) * tileSize.height);
(tileRange.minX - tileCoord.x) * tileSize[0],
(tileCoord.y - tileRange.maxY) * tileSize[1]);
this.tileCache_.set(key, [tile, symbolSizes, maxSymbolSize]);
}
finalContext.drawImage(tile,
tileSize.width * (tileCoord.x - tileRange.minX),
tileSize.height * (tileRange.maxY - tileCoord.y));
tileSize[0] * (tileCoord.x - tileRange.minX),
tileSize[1] * (tileRange.maxY - tileCoord.y));
}
this.renderedResolution_ = tileResolution;