290 lines
11 KiB
Kotlin
290 lines
11 KiB
Kotlin
package net.shadowfacts.asmr.ui
|
|
|
|
import net.shadowfacts.asmr.program.*
|
|
import net.shadowfacts.asmr.program.execution.ExecutableBlock
|
|
import net.shadowfacts.asmr.program.execution.IncomingExecutionFlow
|
|
import net.shadowfacts.asmr.program.execution.OutgoingExecutionFlow
|
|
import net.shadowfacts.asmr.ui.block.ProgramBlockConnectionIndicatorView
|
|
import net.shadowfacts.asmr.ui.block.ProgramBlockExecutionView
|
|
import net.shadowfacts.asmr.ui.block.ProgramBlockParamView
|
|
import net.shadowfacts.asmr.ui.block.ProgramBlockView
|
|
import net.shadowfacts.cacao.geometry.Point
|
|
import net.shadowfacts.cacao.util.Color
|
|
import net.shadowfacts.cacao.util.MouseButton
|
|
import net.shadowfacts.cacao.util.RenderHelper
|
|
import net.shadowfacts.cacao.view.View
|
|
|
|
/**
|
|
* @author shadowfacts
|
|
*/
|
|
class ProgramCanvasView(val program: Program): View() {
|
|
|
|
private lateinit var blocks: Map<ProgramBlock, ProgramBlockView>
|
|
|
|
// map of starting block to (start, end) points
|
|
private val executionFlowStartLinks = mutableMapOf<ExecutableBlock, Pair<Point, Point>>()
|
|
private val parameterLinks = mutableMapOf<ProgramBlock, Pair<Point, Point>>()
|
|
|
|
private var currentPartialLink: PartialLink? = null
|
|
|
|
override fun wasAdded() {
|
|
super.wasAdded()
|
|
|
|
zIndex = 5.0
|
|
|
|
blocks = program.blocks.associateWith { ProgramBlockView(it) }
|
|
blocks.values.forEach {
|
|
addSubview(it)
|
|
}
|
|
}
|
|
|
|
private fun updateBlockLinks() {
|
|
for ((startBlock, startView) in blocks) {
|
|
(startBlock as? ExecutableBlock)?.let { startBlock ->
|
|
for (outgoing in startBlock.outgoing) {
|
|
val outgoingView = startView.outgoingViews[outgoing] ?: continue
|
|
val start = outgoingView.convert(outgoingView.bounds.center, to = this)
|
|
val incoming = outgoing.destination
|
|
if (incoming != null) {
|
|
val incomingBlockView = blocks[incoming.block] ?: continue
|
|
val incomingView = incomingBlockView.incomingView!!
|
|
val end = incomingView.convert(incomingView.bounds.center, to = this)
|
|
|
|
executionFlowStartLinks[startBlock] = start to end
|
|
} else {
|
|
executionFlowStartLinks.remove(startBlock)
|
|
}
|
|
}
|
|
}
|
|
|
|
for (output in startBlock.outputs) {
|
|
val outputView = startView.outputViews[output] ?: continue
|
|
val start = outputView.convert(outputView.bounds.center, to = this)
|
|
|
|
for (destination in output.destinations) {
|
|
val endView = blocks[destination.block] ?: continue
|
|
val inputView = endView.inputViews[destination] ?: continue
|
|
val end = inputView.convert(inputView.bounds.center, to = this)
|
|
|
|
parameterLinks[startBlock] = start to end
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun didLayout() {
|
|
super.didLayout()
|
|
|
|
// we can't calculate the link points until layout is completed and all of the views have concrete positions/sizes
|
|
updateBlockLinks()
|
|
}
|
|
|
|
override fun drawContent(mouse: Point, delta: Float) {
|
|
super.drawContent(mouse, delta)
|
|
|
|
for ((start, end) in executionFlowStartLinks.values) {
|
|
RenderHelper.drawLine(start, end, zIndex, 5f, Color.GREEN)
|
|
}
|
|
|
|
for ((start, end) in parameterLinks.values) {
|
|
RenderHelper.drawLine(start, end, zIndex, 5f, Color.RED)
|
|
}
|
|
|
|
val currentPartialLink = currentPartialLink
|
|
if (currentPartialLink != null) {
|
|
val color = if (currentPartialLink is ParamInputPartialLink<*> || currentPartialLink is ParamOutputPartialLink<*>) Color.RED else Color.GREEN
|
|
RenderHelper.drawLine(currentPartialLink.startPoint, mouse, zIndex, 5f, color)
|
|
}
|
|
}
|
|
|
|
override fun mouseClicked(point: Point, mouseButton: MouseButton): Boolean {
|
|
if (mouseButton == MouseButton.RIGHT && currentPartialLink != null) {
|
|
this.currentPartialLink = null
|
|
return true
|
|
}
|
|
|
|
for ((block, blockView) in blocks) {
|
|
if (convert(point, to = blockView) !in blockView.bounds) continue
|
|
|
|
for ((input, inputView) in blockView.inputViews) {
|
|
if (convert(point, to = inputView) in inputView.bounds) {
|
|
return inputViewClicked(block, input, inputView, mouseButton)
|
|
}
|
|
}
|
|
for ((output, outputView) in blockView.outputViews) {
|
|
if (convert(point, to = outputView) in outputView.bounds) {
|
|
return outputViewClicked(block, output, outputView, mouseButton)
|
|
}
|
|
}
|
|
|
|
if (block is ExecutableBlock) {
|
|
if (convert(point, to = blockView.incomingView!!) in blockView.incomingView!!.bounds) {
|
|
return incomingExecutionViewClicked(block, block.incoming, blockView.incomingView!!, mouseButton)
|
|
}
|
|
for ((outgoing, outgoingView) in blockView.outgoingViews) {
|
|
if (convert(point, to = outgoingView) in outgoingView.bounds) {
|
|
return outgoingExecutionViewClicked(block, outgoing, outgoingView, mouseButton)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return super.mouseClicked(point, mouseButton)
|
|
}
|
|
|
|
private fun <Type: Any> inputViewClicked(block: ProgramBlock, input: ProgramBlockInput<Type>, inputView: ProgramBlockParamView, mouseButton: MouseButton): Boolean {
|
|
val currentPartialLink = currentPartialLink
|
|
return if (currentPartialLink == null) {
|
|
// no partial link in progress
|
|
when (mouseButton) {
|
|
MouseButton.LEFT -> {
|
|
// begin a new one
|
|
this.currentPartialLink = ParamInputPartialLink(input, inputView, inputView.convert(inputView.bounds.center, to = this))
|
|
true
|
|
}
|
|
MouseButton.RIGHT -> {
|
|
// clear clicked connection
|
|
val source = input.source ?: return false
|
|
val outputView = blocks[source.block]?.outputViews?.get(source) ?: return false
|
|
input.unlink()
|
|
inputView.updateTexture()
|
|
outputView.updateTexture()
|
|
updateBlockLinks()
|
|
true
|
|
}
|
|
else -> false
|
|
}
|
|
} else if (currentPartialLink is ParamOutputPartialLink<*> && currentPartialLink.output.type == input.type) {
|
|
// current link in progress originated with an output param of same type as clicked input, so complete it
|
|
// we can ignore the unchecked cast because we checked it ourselves above by comparing ProgramTypes, but the compiler doesn't know that
|
|
@Suppress("NAME_SHADOWING", "UNCHECKED_CAST")
|
|
val currentPartialLink = currentPartialLink as ParamOutputPartialLink<Type>
|
|
currentPartialLink.output.link(to = input)
|
|
currentPartialLink.view.updateTexture()
|
|
inputView.updateTexture()
|
|
updateBlockLinks()
|
|
this.currentPartialLink = null
|
|
true
|
|
} else {
|
|
// otherwise, click always fails
|
|
false
|
|
}
|
|
}
|
|
|
|
private fun <Type: Any> outputViewClicked(block: ProgramBlock, output: ProgramBlockOutput<Type>, outputView: ProgramBlockParamView, mouseButton: MouseButton): Boolean {
|
|
val currentPartialLink = currentPartialLink
|
|
return if (currentPartialLink == null) {
|
|
// no partial link in progress
|
|
when (mouseButton) {
|
|
MouseButton.LEFT -> {
|
|
// begin a new one
|
|
this.currentPartialLink = ParamOutputPartialLink(output, outputView, outputView.convert(outputView.bounds.center, to = this))
|
|
true
|
|
}
|
|
MouseButton.RIGHT -> {
|
|
// clear clicked connection
|
|
val inputViews = output.destinations.mapNotNull { blocks[it.block]?.inputViews?.get(it) }
|
|
output.unlinkAll()
|
|
outputView.updateTexture()
|
|
inputViews.forEach(ProgramBlockParamView::updateTexture)
|
|
updateBlockLinks()
|
|
true
|
|
}
|
|
else -> false
|
|
}
|
|
} else if (currentPartialLink is ParamInputPartialLink<*> && currentPartialLink.input.type == output.type) {
|
|
// current link in progress originated with an input param of same type as clicked output, so complete it
|
|
// we can ignore the unchecked cast because we checked it ourselves above by comparing ProgramTypes, but the compiler doesn't know that
|
|
@Suppress("NAME_SHADOWING", "UNCHECKED_CAST")
|
|
val currentPartialLink = currentPartialLink as ParamInputPartialLink<Type>
|
|
currentPartialLink.input.link(from = output)
|
|
currentPartialLink.view.updateTexture()
|
|
outputView.updateTexture()
|
|
updateBlockLinks()
|
|
this.currentPartialLink = null
|
|
true
|
|
} else {
|
|
// otherwise, click always fails
|
|
false
|
|
}
|
|
}
|
|
|
|
private fun incomingExecutionViewClicked(block: ProgramBlock, incoming: IncomingExecutionFlow, incomingView: ProgramBlockExecutionView, mouseButton: MouseButton): Boolean {
|
|
val currentPartialLink = currentPartialLink
|
|
return if (currentPartialLink == null) {
|
|
// no partial link in progress
|
|
when (mouseButton) {
|
|
MouseButton.LEFT -> {
|
|
// being a new one
|
|
this.currentPartialLink = IncomingExecutionPartialLink(incoming, incomingView, incomingView.convert(incomingView.bounds.center, to = this))
|
|
true
|
|
}
|
|
MouseButton.RIGHT -> {
|
|
// clear clicked connection
|
|
val outgoing = incoming.source ?: return false
|
|
val outgoingView = blocks[outgoing.block]?.outgoingViews?.get(outgoing) ?: return false
|
|
incoming.unlink()
|
|
incomingView.updateTexture()
|
|
outgoingView.updateTexture()
|
|
updateBlockLinks()
|
|
true
|
|
}
|
|
else -> false
|
|
}
|
|
} else if (currentPartialLink is OutgoingExecutionPartialLink) {
|
|
// current link in progress originated with an outgoing execution connection, so complete it
|
|
currentPartialLink.outgoing.link(incoming)
|
|
currentPartialLink.view.updateTexture()
|
|
incomingView.updateTexture()
|
|
updateBlockLinks()
|
|
this.currentPartialLink = null
|
|
true
|
|
} else {
|
|
// otherwise, click always fails
|
|
false
|
|
}
|
|
}
|
|
|
|
private fun outgoingExecutionViewClicked(block: ProgramBlock, outgoing: OutgoingExecutionFlow, outgoingView: ProgramBlockExecutionView, mouseButton: MouseButton): Boolean {
|
|
val currentPartialLink = currentPartialLink
|
|
return if (currentPartialLink == null) {
|
|
// no partial link in progress
|
|
when (mouseButton) {
|
|
MouseButton.LEFT -> {
|
|
// begin a new one
|
|
this.currentPartialLink = OutgoingExecutionPartialLink(outgoing, outgoingView, outgoingView.convert(outgoingView.bounds.center, to = this))
|
|
true
|
|
}
|
|
MouseButton.RIGHT -> {
|
|
// clear clicked connection
|
|
val incoming = outgoing.destination ?: return false
|
|
val incomingView = blocks[incoming.block]?.incomingView ?: return false
|
|
outgoing.unlink()
|
|
outgoingView.updateTexture()
|
|
incomingView.updateTexture()
|
|
updateBlockLinks()
|
|
true
|
|
}
|
|
else -> false
|
|
}
|
|
} else if (currentPartialLink is IncomingExecutionPartialLink) {
|
|
// current link in progress originated with an incoming execution connection, so complete it
|
|
currentPartialLink.incoming.link(outgoing)
|
|
currentPartialLink.view.updateTexture()
|
|
outgoingView.updateTexture()
|
|
updateBlockLinks()
|
|
this.currentPartialLink = null
|
|
true
|
|
} else {
|
|
// otherwise, click always fails
|
|
false
|
|
}
|
|
}
|
|
|
|
open class PartialLink(val view: ProgramBlockConnectionIndicatorView, val startPoint: Point)
|
|
class ParamInputPartialLink<Type: Any>(val input: ProgramBlockInput<Type>, view: ProgramBlockParamView, startPoint: Point): PartialLink(view, startPoint)
|
|
class ParamOutputPartialLink<Type: Any>(val output: ProgramBlockOutput<Type>, view: ProgramBlockParamView, startPoint: Point): PartialLink(view, startPoint)
|
|
class IncomingExecutionPartialLink(val incoming: IncomingExecutionFlow, view: ProgramBlockExecutionView, startPoint: Point): PartialLink(view, startPoint)
|
|
class OutgoingExecutionPartialLink(val outgoing: OutgoingExecutionFlow, view: ProgramBlockExecutionView, startPoint: Point): PartialLink(view, startPoint)
|
|
|
|
} |