# all files / ol/control/ control.js

100% Statements 36/36
93.75% Branches 15/16
100% Functions 5/5
100% Lines 36/36

    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
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    1411×

    1×
    1×
    1×
    1×
    1×

    1×

    348×

    348×

    348×

    348×

    348×

    348×

    348×
    3×

    1×

    1×
    10×
    10×

    1×
    10×

    1×
    341×
    1×

    341×
    1×
    1×

    341×
    341×
    340×

    340×
    340×
    229×

    340×

    1×
    3×

     goog.provide('ol.control.Control');

    goog.require('goog.dom');
    goog.require('goog.events');
    goog.require('ol');
    goog.require('ol.MapEventType');
    goog.require('ol.Object');

    /**
     * @classdesc
     * A control is a visible widget with a DOM element in a fixed position on the
     * screen. They can involve user input (buttons), or be informational only;
     * the position is determined using CSS. By default these are placed in the
     * container with CSS class name `ol-overlaycontainer-stopevent`, but can use
     * any outside DOM element.
     *
     * This is the base class for controls. You can use it for simple custom
     * controls by creating the element with listeners, creating an instance:
     * ```js
     * var myControl = new ol.control.Control({element: myElement});
     * ```
     * and then adding this to the map.
     *
     * The main advantage of having this as a control rather than a simple separate
     * DOM element is that preventing propagation is handled for you. Controls
     * will also be `ol.Object`s in a `ol.Collection`, so you can use their
     * methods.
     *
     * You can also extend this base for your own control class. See
     * examples/custom-controls for an example of how to do this.
     *
     * @constructor
     * @extends {ol.Object}
     * @implements {oli.control.Control}
     * @param {olx.control.ControlOptions} options Control options.
     * @api stable
     */
    ol.control.Control = function(options) {

      goog.base(this);

      /**
       * @protected
       * @type {Element}
       */
      this.element = options.element ? options.element : null;

      /**
       * @private
       * @type {Element}
       */
      this.target_ = null;

      /**
       * @private
       * @type {ol.Map}
       */
      this.map_ = null;

      /**
       * @protected
       * @type {!Array.<?number>}
       */
      this.listenerKeys = [];

      /**
       * @type {function(ol.MapEvent)}
       */
      this.render = options.render ? options.render : ol.nullFunction;

      if (options.target) {
        this.setTarget(options.target);
      }

    };
    goog.inherits(ol.control.Control, ol.Object);

    /**
     * @inheritDoc
     */
    ol.control.Control.prototype.disposeInternal = function() {
      goog.dom.removeNode(this.element);
      goog.base(this, 'disposeInternal');
    };

    /**
     * Get the map associated with this control.
     * @return {ol.Map} Map.
     * @api stable
     */
    ol.control.Control.prototype.getMap = function() {
      return this.map_;
    };

    /**
     * Remove the control from its current map and attach it to the new map.
     * Subclasses may set up event handlers to get notified about changes to
     * the map here.
     * @param {ol.Map} map Map.
     * @api stable
     */
    ol.control.Control.prototype.setMap = function(map) {
      if (this.map_) {
        goog.dom.removeNode(this.element);
      }
      if (this.listenerKeys.length > 0) {
        this.listenerKeys.forEach(goog.events.unlistenByKey);
        this.listenerKeys.length = 0;
      }
      this.map_ = map;
      if (this.map_) {
        var target = this.target_ ?
            this.target_ : map.getOverlayContainerStopEvent();
        target.appendChild(this.element);
        if (this.render !== ol.nullFunction) {
          this.listenerKeys.push(goog.events.listen(map,
              ol.MapEventType.POSTRENDER, this.render, false, this));
        }
        map.render();
      }
    };

    /**
     * This function is used to set a target element for the control. It has no
     * effect if it is called after the control has been added to the map (i.e.
     * after `setMap` is called on the control). If no `target` is set in the
     * options passed to the control constructor and if `setTarget` is not called
     * then the control is added to the map's overlay container.
     * @param {Element|string} target Target.
     * @api
     */
    ol.control.Control.prototype.setTarget = function(target) {
      this.target_ = goog.dom.getElement(target);
    };