# all files / ol/source/ tiledebugsource.js

32.56% Statements 14/43
0% Branches 0/10
0% Functions 0/4
32.56% Lines 14/43

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    1231×

    1×
    1×
    1×
    1×
    1×
    1×
    1×

    1×

    1×

    1×

    1×

    1×

    1×

     goog.provide('ol.source.TileDebug');

    goog.require('ol.Tile');
    goog.require('ol.TileCoord');
    goog.require('ol.TileState');
    goog.require('ol.dom');
    goog.require('ol.size');
    goog.require('ol.source.Tile');
    goog.require('ol.tilecoord');

    /**
     * @constructor
     * @extends {ol.Tile}
     * @param {ol.TileCoord} tileCoord Tile coordinate.
     * @param {ol.Size} tileSize Tile size.
     * @param {string} text Text.
     * @private
     */
    ol.DebugTile_ = function(tileCoord, tileSize, text) {

      goog.base(this, tileCoord, ol.TileState.LOADED);

      /**
       * @private
       * @type {ol.Size}
       */
      this.tileSize_ = tileSize;

      /**
       * @private
       * @type {string}
       */
      this.text_ = text;

      /**
       * @private
       * @type {Object.<number, HTMLCanvasElement>}
       */
      this.canvasByContext_ = {};

    };
    goog.inherits(ol.DebugTile_, ol.Tile);

    /**
     * Get the image element for this tile.
     * @param {Object=} opt_context Optional context. Only used by the DOM
     *     renderer.
     * @return {HTMLCanvasElement} Image.
     */
    ol.DebugTile_.prototype.getImage = function(opt_context) {
      var key = opt_context !== undefined ? goog.getUid(opt_context) : -1;
      if (key in this.canvasByContext_) {
        return this.canvasByContext_[key];
      } else {

        var tileSize = this.tileSize_;
        var context = ol.dom.createCanvasContext2D(tileSize[0], tileSize[1]);

        context.strokeStyle = 'black';
        context.strokeRect(0.5, 0.5, tileSize[0] + 0.5, tileSize[1] + 0.5);

        context.fillStyle = 'black';
        context.textAlign = 'center';
        context.textBaseline = 'middle';
        context.font = '24px sans-serif';
        context.fillText(this.text_, tileSize[0] / 2, tileSize[1] / 2);

        this.canvasByContext_[key] = context.canvas;
        return context.canvas;

      }
    };

    /**
     * @classdesc
     * A pseudo tile source, which does not fetch tiles from a server, but renders
     * a grid outline for the tile grid/projection along with the coordinates for
     * each tile. See examples/canvas-tiles for an example.
     *
     * Uses Canvas context2d, so requires Canvas support.
     *
     * @constructor
     * @extends {ol.source.Tile}
     * @param {olx.source.TileDebugOptions} options Debug tile options.
     * @api
     */
    ol.source.TileDebug = function(options) {

      goog.base(this, {
        opaque: false,
        projection: options.projection,
        tileGrid: options.tileGrid,
        wrapX: options.wrapX !== undefined ? options.wrapX : true
      });

    };
    goog.inherits(ol.source.TileDebug, ol.source.Tile);

    /**
     * @inheritDoc
     */
    ol.source.TileDebug.prototype.getTile = function(z, x, y) {
      var tileCoordKey = this.getKeyZXY(z, x, y);
      if (this.tileCache.containsKey(tileCoordKey)) {
        return /** @type {!ol.DebugTile_} */ (this.tileCache.get(tileCoordKey));
      } else {
        var tileSize = ol.size.toSize(this.tileGrid.getTileSize(z));
        var tileCoord = [z, x, y];
        var textTileCoord = this.getTileCoordForTileUrlFunction(tileCoord);
        var text = !textTileCoord ? '' : ol.tilecoord.toString(
            this.getTileCoordForTileUrlFunction(textTileCoord));
        var tile = new ol.DebugTile_(tileCoord, tileSize, text);
        this.tileCache.set(tileCoordKey, tile);
        return tile;
      }
    };