Remove canvas renderer

gis/src/commonMain/kotlin/jetbrains/gis/tileprotocol/socket/TileWebSocket.kt

@@ -1,7 +1,7 @@
 package jetbrains.gis.tileprotocol.socket
 
 import io.ktor.client.HttpClient
-import io.ktor.client.features.websocket.ws
+import io.ktor.client.features.websocket.wss
 import io.ktor.http.DEFAULT_PORT
 import io.ktor.http.HttpMethod
 import io.ktor.http.cio.websocket.Frame
@@ -26,7 +26,7 @@ class TileWebSocket(
  override fun connect() {
  with(myClient) {
  launch {
- ws(
+ wss(
  method = HttpMethod.Get,
  host = myHost,
  port = myPort ?: DEFAULT_PORT

plot-builder/src/commonMain/kotlin/jetbrains/datalore/plot/builder/Plot.kt

@@ -35,7 +35,7 @@ abstract class Plot(private val theme: Theme) : SvgComponent() {
  private val myPreferredSize = ValueProperty(jetbrains.datalore.plot.builder.Plot.Companion.DEF_PLOT_SIZE)
  private val myLaidOutSize = ValueProperty(DoubleVector.ZERO)
  private val myTooltipHelper = jetbrains.datalore.plot.builder.PlotTooltipHelper()
- private val myCanvasFigures = ArrayList<CanvasFigure>()
+ private val myLiveMapFigures = ArrayList<CanvasFigure>()
 
  internal val mouseEventPeer = jetbrains.datalore.plot.builder.event.MouseEventPeer()
 
@@ -57,10 +57,8 @@ abstract class Plot(private val theme: Theme) : SvgComponent() {
 
  abstract val isInteractionsEnabled: Boolean
 
- protected abstract val isCanvasEnabled: Boolean
-
- internal val tileCanvasFigures: List<CanvasFigure>
- get() = myCanvasFigures
+ internal val liveMapFigures: List<CanvasFigure>
+ get() = myLiveMapFigures
 
  internal fun preferredSize(): WritableProperty<DoubleVector> {
  return myPreferredSize
@@ -120,7 +118,7 @@ abstract class Plot(private val theme: Theme) : SvgComponent() {
  reg(object : Registration() {
  override fun doRemove() {
  myTooltipHelper.removeAllTileInfos()
- myCanvasFigures.clear()
+ myLiveMapFigures.clear()
  }
  })
  }
@@ -161,7 +159,6 @@ abstract class Plot(private val theme: Theme) : SvgComponent() {
  jetbrains.datalore.plot.builder.PlotTile(tileLayers, xScale, yScale, tilesOrigin, tileInfo, coord, theme)
  tile.setShowAxis(isAxisEnabled)
  tile.debugDrawing().set(jetbrains.datalore.plot.builder.Plot.Companion.DEBUG_DRAWING)
- tile.setUseCanvas(isCanvasEnabled)
 
  return tile
  }
@@ -320,7 +317,7 @@ abstract class Plot(private val theme: Theme) : SvgComponent() {
 
  add(tile)
 
- myCanvasFigures.addAll(tile.canvasFigures)
+ tile.liveMapFigure?.let(myLiveMapFigures::add)
 
  val realGeomBounds = tileInfo.geomBounds.add(tilesOrigin.add(tileInfo.plotOffset))
  myTooltipHelper.addTileInfo(realGeomBounds, tile.targetLocators)

plot-builder/src/commonMain/kotlin/jetbrains/datalore/plot/builder/PlotBuilder.kt

@@ -8,7 +8,7 @@ import jetbrains.datalore.plot.builder.theme.Theme
 import jetbrains.datalore.visualization.plot.base.Scale
 
 class PlotBuilder(private val myTheme: Theme) {
- private val myLayersByTile = ArrayList<List<jetbrains.datalore.plot.builder.GeomLayer>>()
+ private val myLayersByTile = ArrayList<List<GeomLayer>>()
  private var myTitle: String? = null
  private lateinit var myCoordProvider: jetbrains.datalore.plot.builder.coord.CoordProvider
  private var myLayout: PlotLayout? = null
@@ -19,7 +19,6 @@ class PlotBuilder(private val myTheme: Theme) {
  private lateinit var myScaleYProto: Scale<Double>
  private var myAxisEnabled = true
  private var myInteractionsEnabled = true
- private var myCanvasEnabled = false
 
  fun setTitle(title: String?) {
  myTitle = title
@@ -33,57 +32,51 @@ class PlotBuilder(private val myTheme: Theme) {
  myAxisTitleBottom = v
  }
 
- fun setCoordProvider(coordProvider: jetbrains.datalore.plot.builder.coord.CoordProvider): jetbrains.datalore.plot.builder.PlotBuilder {
+ fun setCoordProvider(coordProvider: jetbrains.datalore.plot.builder.coord.CoordProvider): PlotBuilder {
  myCoordProvider = coordProvider
  return this
  }
 
- fun addTileLayers(tileLayers: List<jetbrains.datalore.plot.builder.GeomLayer>): jetbrains.datalore.plot.builder.PlotBuilder {
+ fun addTileLayers(tileLayers: List<GeomLayer>): PlotBuilder {
  myLayersByTile.add(ArrayList(tileLayers))
  return this
  }
 
- fun setPlotLayout(layout: PlotLayout): jetbrains.datalore.plot.builder.PlotBuilder {
+ fun setPlotLayout(layout: PlotLayout): PlotBuilder {
  myLayout = layout
  return this
  }
 
- fun addLegendBoxInfo(v: LegendBoxInfo): jetbrains.datalore.plot.builder.PlotBuilder {
+ fun addLegendBoxInfo(v: LegendBoxInfo): PlotBuilder {
  myLegendBoxInfos.add(v)
  return this
  }
 
- fun scaleXProto(scaleXProto: Scale<Double>): jetbrains.datalore.plot.builder.PlotBuilder {
+ fun scaleXProto(scaleXProto: Scale<Double>): PlotBuilder {
  myScaleXProto = scaleXProto
  return this
  }
 
- fun scaleYProto(scaleYProto: Scale<Double>): jetbrains.datalore.plot.builder.PlotBuilder {
+ fun scaleYProto(scaleYProto: Scale<Double>): PlotBuilder {
  myScaleYProto = scaleYProto
  return this
  }
 
- fun axisEnabled(b: Boolean): jetbrains.datalore.plot.builder.PlotBuilder {
+ fun axisEnabled(b: Boolean): PlotBuilder {
  myAxisEnabled = b
  return this
  }
 
- fun interactionsEnabled(b: Boolean): jetbrains.datalore.plot.builder.PlotBuilder {
+ fun interactionsEnabled(b: Boolean): PlotBuilder {
  myInteractionsEnabled = b
  return this
  }
 
- fun canvasEnabled(b: Boolean): jetbrains.datalore.plot.builder.PlotBuilder {
- myCanvasEnabled = b
- return this
- }
-
- fun build(): jetbrains.datalore.plot.builder.Plot {
- return jetbrains.datalore.plot.builder.PlotBuilder.MyPlot(this)
+ fun build(): Plot {
+ return MyPlot(this)
  }
 
-
- private class MyPlot(b: jetbrains.datalore.plot.builder.PlotBuilder) : jetbrains.datalore.plot.builder.Plot(b.myTheme) {
+ private class MyPlot(b: PlotBuilder) : Plot(b.myTheme) {
  override val scaleXProto: Scale<Double> = b.myScaleXProto
  override val scaleYProto: Scale<Double> = b.myScaleYProto
 
@@ -95,13 +88,12 @@ class PlotBuilder(private val myTheme: Theme) {
 
  override val coordProvider: jetbrains.datalore.plot.builder.coord.CoordProvider = b.myCoordProvider
 
- private val myLayersByTile: List<List<jetbrains.datalore.plot.builder.GeomLayer>>
+ private val myLayersByTile: List<List<GeomLayer>>
  private val myLayout: PlotLayout?
  private val myLegendBoxInfos: List<LegendBoxInfo>
 
  override val isAxisEnabled: Boolean
  override val isInteractionsEnabled: Boolean
- override val isCanvasEnabled: Boolean
 
  override val title: String
  get() {
@@ -131,7 +123,6 @@ class PlotBuilder(private val myTheme: Theme) {
 
  isAxisEnabled = b.myAxisEnabled
  isInteractionsEnabled = b.myInteractionsEnabled
- isCanvasEnabled = b.myCanvasEnabled
  }
 
  override fun hasTitle(): Boolean {
@@ -146,7 +137,7 @@ class PlotBuilder(private val myTheme: Theme) {
  return myAxisXTitleEnabled && !Strings.isNullOrEmpty(myAxisTitleBottom)
  }
 
- override fun tileLayers(tileIndex: Int): List<jetbrains.datalore.plot.builder.GeomLayer> {
+ override fun tileLayers(tileIndex: Int): List<GeomLayer> {
  return myLayersByTile[tileIndex]
  }
 

plot-builder/src/commonMain/kotlin/jetbrains/datalore/plot/builder/PlotContainer.kt

@@ -31,8 +31,8 @@ class PlotContainer(
  private var myContentBuilt: Boolean = false
  private var myRegistrations = CompositeRegistration()
 
- val tileCanvasFigures: List<CanvasFigure>
- get() = plot.tileCanvasFigures
+ val liveMapFigures: List<CanvasFigure>
+ get() = plot.liveMapFigures
 
  val mouseEventPeer: jetbrains.datalore.plot.builder.event.MouseEventPeer
  get() = plot.mouseEventPeer
@@ -147,14 +147,6 @@ class PlotContainer(
  }))
  }
 
-// unused?
-// fun createCanvasFigure(): CanvasFigure {
-// val canvasFigure = SvgCanvasFigure()
-// canvasFigure.svgGElement.children().add(svg)
-// canvasFigure.setBounds(DoubleRectangle(DoubleVector.ZERO, myLaidOutSize.get()))
-// return canvasFigure
-// }
-
  companion object {
  private fun sizePropHandler(block: (newValue: DoubleVector) -> Unit): EventHandler<PropertyChangeEvent<out DoubleVector>> {
  return object : EventHandler<PropertyChangeEvent<out DoubleVector>> {

plot-builder/src/commonMain/kotlin/jetbrains/datalore/plot/builder/PlotTile.kt

@@ -12,7 +12,6 @@ import jetbrains.datalore.plot.builder.presentation.Style
 import jetbrains.datalore.plot.builder.theme.AxisTheme
 import jetbrains.datalore.plot.builder.theme.Theme
 import jetbrains.datalore.visualization.base.canvasFigure.CanvasFigure
-import jetbrains.datalore.visualization.base.canvasFigure.SvgCanvasFigure
 import jetbrains.datalore.visualization.base.svg.SvgRectElement
 import jetbrains.datalore.visualization.plot.base.Aes
 import jetbrains.datalore.visualization.plot.base.CoordinateSystem
@@ -23,7 +22,7 @@ import jetbrains.datalore.visualization.plot.base.render.svg.TextLabel
 import jetbrains.datalore.visualization.plot.base.scale.Mappers
 
 internal class PlotTile(
- layers: List<jetbrains.datalore.plot.builder.GeomLayer>,
+ layers: List<GeomLayer>,
  private val myScaleX: Scale<Double>,
  private val myScaleY: Scale<Double>,
  private val myTilesOrigin: DoubleVector,
@@ -33,16 +32,12 @@ internal class PlotTile(
 ) : SvgComponent() {
 
  private val myDebugDrawing = ValueProperty(false)
-
- private val myLayers: List<jetbrains.datalore.plot.builder.GeomLayer>
- private val myCanvasFigures = ArrayList<CanvasFigure>()
+ private val myLayers: List<GeomLayer>
  private val myTargetLocators = ArrayList<GeomTargetLocator>()
-
  private var myShowAxis: Boolean = false
- private var myUseCanvas: Boolean = false
 
- val canvasFigures: List<CanvasFigure>
- get() = myCanvasFigures
+ var liveMapFigure: CanvasFigure? = null
+ private set
 
  val targetLocators: List<GeomTargetLocator>
  get() = myTargetLocators
@@ -67,7 +62,7 @@ internal class PlotTile(
  val geomBounds = myLayoutInfo.geomBounds
  addFacetLabels(geomBounds)
 
- val isLivemap = jetbrains.datalore.plot.builder.GeomLayerListUtil.containsLivemapLayer2(myLayers)
+ val isLivemap = GeomLayerListUtil.containsLivemapLayer2(myLayers)
  if (!isLivemap && myShowAxis) {
  addAxis(geomBounds)
  }
@@ -102,18 +97,18 @@ internal class PlotTile(
 
  if (isLivemap) {
  // 'live map' requires all positions to be passed "as is", without mapping
- val liveMapLayer = jetbrains.datalore.plot.builder.GeomLayerListUtil.getLivemapLayer(myLayers)
+ val liveMapLayer = GeomLayerListUtil.getLivemapLayer(myLayers)
  val origin = myLayoutInfo.getAbsoluteGeomBounds(myTilesOrigin).origin
  val liveMapLayerRenderer =
- jetbrains.datalore.plot.builder.LayerRendererUtil.createLivemapLayerRenderer(liveMapLayer, myLayers)
+ LayerRendererUtil.createLivemapLayerRenderer(liveMapLayer, myLayers)
 
  val rectElement = SvgRectElement(geomBounds)
  rectElement.addClass(Style.PLOT_GLASS_PANE)
  rectElement.opacity().set(0.0)
  add(rectElement)
 
  liveMapLayerRenderer.createLiveMapData(DoubleRectangle(origin, geomBounds.dimension)).let {
- myCanvasFigures.add(it.canvasFigure)
+ liveMapFigure = it.canvasFigure
  myTargetLocators.add(it.targetLocator)
  }
  } else {
@@ -136,17 +131,8 @@ internal class PlotTile(
  val geomLayerRenderers = buildGeoms(sharedNumericMappers, overallNumericDomains, myCoord)
  for (layerRenderer in geomLayerRenderers) {
  val layerComponent = layerRenderer as SvgComponent
- if (myUseCanvas) {
- // SVG on canvas
- val svgCanvasFigure = SvgCanvasFigure()
- svgCanvasFigure.svgGElement.children().add(layerComponent.rootGroup)
- svgCanvasFigure.setBounds(myLayoutInfo.getAbsoluteGeomBounds(myTilesOrigin))
- myCanvasFigures.add(svgCanvasFigure)
- } else {
- // regular SVG
- layerComponent.moveTo(geomBounds.origin)
- add(layerComponent)
- }
+ layerComponent.moveTo(geomBounds.origin)
+ add(layerComponent)
  }
  }
  }
@@ -156,7 +142,7 @@ internal class PlotTile(
  if (myLayoutInfo.facetXLabel != null) {
  val lab = TextLabel(myLayoutInfo.facetXLabel)
  val w = geomBounds.width
- val h = jetbrains.datalore.plot.builder.PlotTile.Companion.FACET_LABEL_HEIGHT
+ val h = FACET_LABEL_HEIGHT
  val x = geomBounds.left + w / 2
  val y = geomBounds.top - h / 2
 
@@ -169,7 +155,7 @@ internal class PlotTile(
  // facet Y label (to the right from geom area)
  if (myLayoutInfo.facetYLabel != null) {
  val lab = TextLabel(myLayoutInfo.facetYLabel)
- val w = jetbrains.datalore.plot.builder.PlotTile.Companion.FACET_LABEL_HEIGHT
+ val w = FACET_LABEL_HEIGHT
  val h = geomBounds.height
  val x = geomBounds.right + w / 2
  val y = geomBounds.top + h / 2
@@ -199,9 +185,9 @@ internal class PlotTile(
 
  private fun buildAxis(scale: Scale<Double>, info: AxisLayoutInfo, coord: CoordinateSystem, theme: AxisTheme): jetbrains.datalore.plot.builder.guide.AxisComponent {
  val axis = jetbrains.datalore.plot.builder.guide.AxisComponent(info.axisLength, info.orientation!!)
- jetbrains.datalore.plot.builder.AxisUtil.setBreaks(axis, scale, coord, info.orientation.isHorizontal)
- jetbrains.datalore.plot.builder.AxisUtil.applyLayoutInfo(axis, info)
- jetbrains.datalore.plot.builder.AxisUtil.applyTheme(axis, theme)
+ AxisUtil.setBreaks(axis, scale, coord, info.orientation.isHorizontal)
+ AxisUtil.applyLayoutInfo(axis, info)
+ AxisUtil.applyTheme(axis, theme)
  if (isDebugDrawing) {
  if (info.tickLabelsBounds != null) {
  val rect = SvgRectElement(info.tickLabelsBounds)
@@ -217,11 +203,11 @@ internal class PlotTile(
  private fun buildGeoms(
  sharedNumericMappers: Map<Aes<Double>, (Double?) -> Double?>,
  overallNumericDomains: Map<Aes<Double>, ClosedRange<Double>>,
- coord: CoordinateSystem): List<jetbrains.datalore.plot.builder.GeomLayerRenderer> {
+ coord: CoordinateSystem): List<GeomLayerRenderer> {
 
- val layerRenderers = ArrayList<jetbrains.datalore.plot.builder.GeomLayerRenderer>()
+ val layerRenderers = ArrayList<GeomLayerRenderer>()
  for (layer in myLayers) {
- val rendererData = jetbrains.datalore.plot.builder.LayerRendererUtil.createLayerRendererData(
+ val rendererData = LayerRendererUtil.createLayerRendererData(
  layer,
  sharedNumericMappers,
  overallNumericDomains
@@ -246,7 +232,7 @@ internal class PlotTile(
  val pos = rendererData.pos
  val geom = layer.geom
 
- layerRenderers.add(jetbrains.datalore.plot.builder.SvgLayerRenderer(aesthetics, geom, pos, coord, ctx))
+ layerRenderers.add(SvgLayerRenderer(aesthetics, geom, pos, coord, ctx))
  }
  return layerRenderers
  }
@@ -255,10 +241,6 @@ internal class PlotTile(
  myShowAxis = showAxis
  }
 
- fun setUseCanvas(useCanvas: Boolean) {
- myUseCanvas = useCanvas
- }
-
  fun debugDrawing(): Property<Boolean> {
  return myDebugDrawing
  }

plot-builder/src/commonMain/kotlin/jetbrains/datalore/plot/builder/assemble/PlotAssembler.kt

@@ -22,7 +22,6 @@ class PlotAssembler private constructor(
  private var myAxisEnabled: Boolean = false
  private var myLegendsEnabled = true
  private var myInteractionsEnabled = true
- private var myCanvasEnabled = false
 
  val layersByTile: List<List<jetbrains.datalore.plot.builder.GeomLayer>>
  get() = myLayersByTile
@@ -145,7 +144,6 @@ class PlotAssembler private constructor(
  plotBuilder.setPlotLayout(plotLayout)
  plotBuilder.axisEnabled(myAxisEnabled)
  plotBuilder.interactionsEnabled(myInteractionsEnabled)
- plotBuilder.canvasEnabled(myCanvasEnabled)
  return plotBuilder.build()
  }
 
@@ -165,10 +163,6 @@ class PlotAssembler private constructor(
  myInteractionsEnabled = false
  }
 
- fun enableCanvas() {
- myCanvasEnabled = true
- }
-
  companion object {
  fun singleTile(plotLayers: List<jetbrains.datalore.plot.builder.GeomLayer>, coordProvider: jetbrains.datalore.plot.builder.coord.CoordProvider, theme: Theme): jetbrains.datalore.plot.builder.assemble.PlotAssembler {
  val layersByTile = ArrayList<List<jetbrains.datalore.plot.builder.GeomLayer>>()