_emit_selection_event(geometry: Geometry, final: boolean = true): void {
    const xm = this.plot_model.frame.xscales['default']
    const ym = this.plot_model.frame.yscales['default']
    let g: any // XXX: Geometry & something
    switch (geometry.type) {
      case 'point': {
        const {sx, sy} = geometry
        const x = xm.invert(sx)
        const y = ym.invert(sy)
        g = extend({}, geometry, {x, y})
        break
      }
      case 'rect': {
        const {sx0, sx1, sy0, sy1} = geometry
        const [x0, x1] = xm.r_invert(sx0, sx1)
        const [y0, y1] = ym.r_invert(sy0, sy1)
        g = extend({}, geometry, {x0, y0, x1, y1})
        break
      }
      case 'poly': {
        const {sx, sy} = geometry
        const x = xm.v_invert(sx)
        const y = ym.v_invert(sy)
        g = extend({}, geometry, {x, y})
        break
      }
      default:
        throw new Error(`Unrecognized selection geometry type: '${geometry.type}'`)
    }

    this.plot_model.plot.trigger_event(new SelectionGeometry({geometry: g, final: final}))
  }

  push_state(type, info) {
    const prev_info = (this.state.history[this.state.index] != null ? this.state.history[this.state.index].info : undefined) || {};
    info = extend({}, this._initial_state_info, prev_info, info);

    this.state.history.slice(0, this.state.index + 1);
    this.state.history.push({type, info});
    this.state.index = this.state.history.length - 1;

    return this.state_changed.emit(undefined);
  }

 render(): void {
   super.render()
   empty(this.el)
   const style = extend({
     width: `${this.model.width}px`,
     height: `${this.model.height}px`,
   }, this.model.style)
   this.markupEl = div({style: style})
   this.el.appendChild(this.markupEl)
 }

 doFormat(_row: any, _cell: any, value: any, _columnDef: any, dataContext: any): string {
   const {template} = this
   if (value == null)
     return ""
   else {
     const compiled_template = compile_template(template)
     const context = extend({}, dataContext, {value})
     return compiled_template(context)
   }
 }

 doFormat(_row, _cell, value, _columnDef, dataContext) {
   const { template } = this;
   if (value === null) {
     return "";
   } else {
     dataContext = extend({}, dataContext, {value});
     const compiled_template = compile_template(template);
     return compiled_template(dataContext);
   }
 }

  set_data(source, indices, indices_to_update) {
    let data = this.model.materialize_dataspecs(source);

    this.visuals.set_all_indices(indices);
    if (indices && !(this instanceof LineView)) {
      const data_subset = {};
      for (const k in data) {
        const v = data[k];
        if (k.charAt(0) === '_') {
          data_subset[k] = (indices.map((i) => v[i]));
        } else {
          data_subset[k] = v;
        }
      }
      data = data_subset;
    }

    extend(this, data);

    if (this.renderer.plot_view.model.use_map) {
      if (this._x != null) {
        [this._x, this._y] = proj.project_xy(this._x, this._y);
      }
      if (this._xs != null) {
        [this._xs, this._ys] = proj.project_xsys(this._xs, this._ys);
      }
    }

    // if we have any coordinates that are categorical, convert them to
    // synthetic coords here
    if (this.renderer.plot_view.frame.x_ranges != null) {   // XXXX JUST TEMP FOR TESTS TO PASS
      const xr = this.renderer.plot_view.frame.x_ranges[this.model.x_range_name];
      const yr = this.renderer.plot_view.frame.y_ranges[this.model.y_range_name];
      for (let [xname, yname] of this.model._coords) {
        xname = `_${xname}`;
        yname = `_${yname}`;
        if (xr.v_synthetic != null) {
          this[xname] = xr.v_synthetic(this[xname]);
        }
        if (yr.v_synthetic != null) {
          this[yname] = yr.v_synthetic(this[yname]);
        }
      }
    }

    if (this.glglyph != null) {
      this.glglyph.set_data_changed(this._x.length);
    }

    this._set_data(source, indices_to_update); //TODO doesn't take subset indices into account

    return this.index = this._index_data();
  }

  set_data(source: ColumnarDataSource): void {
    const data = this.model.materialize_dataspecs(source)
    extend(this as any, data)

    if (this.plot_model.use_map) {
      const self = this as any
      if (self._x != null)
        [self._x, self._y] = proj.project_xy(self._x, self._y)
      if (self._xs != null)
        [self._xs, self._ys] = proj.project_xsys(self._xs, self._ys)
    }
  }

  push_state(type: string, new_info: Partial<StateInfo>): void {
    const {history, index} = this.state

    const prev_info = history[index] != null ? history[index].info : {}
    const info = extend({}, this._initial_state_info, prev_info, new_info)

    this.state.history = this.state.history.slice(0, this.state.index + 1)
    this.state.history.push({type, info})
    this.state.index = this.state.history.length - 1

    this.state_changed.emit()
  }

  get_constrained_variables(): {[key: string]: Variable} {
    return extend({}, super.get_constrained_variables(), {
      on_edge_align_top    : this._top,
      on_edge_align_bottom : this._height_minus_bottom,
      on_edge_align_left   : this._left,
      on_edge_align_right  : this._width_minus_right,

      box_cell_align_top   : this._top,
      box_cell_align_bottom: this._height_minus_bottom,
      box_cell_align_left  : this._left,
      box_cell_align_right : this._width_minus_right,

      box_equal_size_top   : this._top,
      box_equal_size_bottom: this._height_minus_bottom,
      box_equal_size_left  : this._left,
      box_equal_size_right : this._width_minus_right,
    })
  }

  get_constrained_variables(): {[key: string]: Variable} {
    const vars = extend({}, super.get_constrained_variables(), {
      on_edge_align_top    : this.plot_canvas._top,
      on_edge_align_bottom : this.plot_canvas._height_minus_bottom,
      on_edge_align_left   : this.plot_canvas._left,
      on_edge_align_right  : this.plot_canvas._width_minus_right,

      box_cell_align_top   : this.plot_canvas._top,
      box_cell_align_bottom: this.plot_canvas._height_minus_bottom,
      box_cell_align_left  : this.plot_canvas._left,
      box_cell_align_right : this.plot_canvas._width_minus_right,

      box_equal_size_top   : this.plot_canvas._top,
      box_equal_size_bottom: this.plot_canvas._height_minus_bottom,
    })

    if (this.sizing_mode != "fixed") {
      vars.box_equal_size_left  = this.plot_canvas._left
      vars.box_equal_size_right = this.plot_canvas._width_minus_right
    }

    return vars
  }