kopia lustrzana https://github.com/Tldraw/Tldraw
503 wiersze
14 KiB
TypeScript
503 wiersze
14 KiB
TypeScript
import {
|
|
ArrowBinding,
|
|
ArrowShape,
|
|
TDShape,
|
|
TDBinding,
|
|
TDStatus,
|
|
SessionType,
|
|
TDShapeType,
|
|
TldrawPatch,
|
|
TldrawCommand,
|
|
} from '~types'
|
|
import { Vec } from '@tldraw/vec'
|
|
import { TLDR } from '~state/TLDR'
|
|
import { shapeUtils } from '~state/shapes'
|
|
import { BaseSession } from '../BaseSession'
|
|
import type { TldrawApp } from '../../internal'
|
|
import { Utils } from '@tldraw/core'
|
|
import { deepCopy } from '~state/StateManager/copy'
|
|
|
|
export class ArrowSession extends BaseSession {
|
|
type = SessionType.Arrow
|
|
performanceMode = undefined
|
|
status = TDStatus.TranslatingHandle
|
|
newStartBindingId = Utils.uniqueId()
|
|
draggedBindingId = Utils.uniqueId()
|
|
didBind = false
|
|
initialShape: ArrowShape
|
|
handleId: 'start' | 'end'
|
|
bindableShapeIds: string[]
|
|
initialBinding?: TDBinding
|
|
startBindingShapeId?: string
|
|
isCreate: boolean
|
|
|
|
constructor(app: TldrawApp, shapeId: string, handleId: 'start' | 'end', isCreate = false) {
|
|
super(app)
|
|
|
|
this.isCreate = isCreate
|
|
|
|
const { currentPageId } = app.state.appState
|
|
|
|
const page = app.state.document.pages[currentPageId]
|
|
|
|
this.handleId = handleId
|
|
|
|
this.initialShape = deepCopy(page.shapes[shapeId] as ArrowShape)
|
|
|
|
this.bindableShapeIds = TLDR.getBindableShapeIds(app.state).filter(
|
|
(id) => !(id === this.initialShape.id || id === this.initialShape.parentId)
|
|
)
|
|
|
|
// TODO: find out why this the oppositeHandleBindingId is sometimes missing
|
|
const oppositeHandleBindingId =
|
|
this.initialShape.handles[handleId === 'start' ? 'end' : 'start']?.bindingId
|
|
|
|
if (oppositeHandleBindingId) {
|
|
const oppositeToId = page.bindings[oppositeHandleBindingId]?.toId
|
|
if (oppositeToId) {
|
|
this.bindableShapeIds = this.bindableShapeIds.filter((id) => id !== oppositeToId)
|
|
}
|
|
}
|
|
|
|
const { originPoint } = this.app
|
|
|
|
if (this.isCreate) {
|
|
// If we're creating a new shape, should we bind its first point?
|
|
// The method may return undefined, which is correct if there is no
|
|
// bindable shape under the pointer.
|
|
this.startBindingShapeId = this.bindableShapeIds
|
|
.map((id) => page.shapes[id])
|
|
.filter(
|
|
(shape) =>
|
|
!shape.isLocked &&
|
|
Utils.pointInBounds(originPoint, TLDR.getShapeUtil(shape).getBounds(shape))
|
|
)
|
|
.sort((a, b) => {
|
|
// TODO - We should be smarter here, what's the right logic?
|
|
return b.childIndex - a.childIndex
|
|
})[0]?.id
|
|
|
|
if (this.startBindingShapeId) {
|
|
this.bindableShapeIds.splice(this.bindableShapeIds.indexOf(this.startBindingShapeId), 1)
|
|
}
|
|
} else {
|
|
// If we're editing an existing line, is there a binding already
|
|
// for the dragging handle?
|
|
const initialBindingId = this.initialShape.handles[this.handleId].bindingId
|
|
|
|
if (initialBindingId) {
|
|
this.initialBinding = page.bindings[initialBindingId]
|
|
} else {
|
|
// If not, explicitly set this handle to undefined, so that it gets deleted on undo
|
|
this.initialShape.handles[this.handleId].bindingId = undefined
|
|
}
|
|
}
|
|
}
|
|
|
|
start = (): TldrawPatch | undefined => void null
|
|
|
|
update = (): TldrawPatch | undefined => {
|
|
const { initialShape } = this
|
|
const {
|
|
currentPoint,
|
|
shiftKey,
|
|
altKey,
|
|
metaKey,
|
|
currentGrid,
|
|
settings: { showGrid },
|
|
} = this.app
|
|
|
|
const shape = this.app.getShape<ArrowShape>(initialShape.id)
|
|
|
|
if (shape.isLocked) return
|
|
|
|
const { handles } = initialShape
|
|
|
|
const handleId = this.handleId as keyof typeof handles
|
|
// If the handle can bind, then we need to search bindable shapes for
|
|
// a binding.
|
|
if (!handles[handleId].canBind) return
|
|
|
|
// Find the delta (in shape space)
|
|
let delta = Vec.sub(currentPoint, Vec.add(handles[handleId].point, initialShape.point))
|
|
|
|
if (shiftKey) {
|
|
const A = altKey
|
|
? Vec.med(handles.start.point, handles.end.point)
|
|
: handles[handleId === 'start' ? 'end' : 'start'].point
|
|
const B = handles[handleId].point
|
|
const C = Vec.add(B, delta)
|
|
|
|
const angle = Vec.angle(A, C)
|
|
|
|
const adjusted = Vec.rotWith(C, A, Utils.snapAngleToSegments(angle, 24) - angle)
|
|
|
|
delta = Vec.add(delta, Vec.sub(adjusted, C))
|
|
}
|
|
|
|
const nextPoint = Vec.add(handles[handleId].point, delta)
|
|
|
|
const handleChanges = {
|
|
[handleId]: {
|
|
...handles[handleId],
|
|
point: showGrid ? Vec.snap(nextPoint, currentGrid) : Vec.toFixed(nextPoint),
|
|
bindingId: undefined,
|
|
},
|
|
}
|
|
|
|
// if (altKey) {
|
|
// // If the user is holding alt key, apply the inverse delta
|
|
// // to the oppoosite handle.
|
|
// const oppositeHandleId = handleId === 'start' ? 'end' : 'start'
|
|
|
|
// const nextPoint = Vec.sub(handles[oppositeHandleId].point, delta)
|
|
|
|
// handleChanges[oppositeHandleId] = {
|
|
// ...handles[oppositeHandleId],
|
|
// point: showGrid ? Vec.snap(nextPoint, currentGrid) : Vec.toFixed(nextPoint),
|
|
// bindingId: undefined,
|
|
// }
|
|
// }
|
|
|
|
const utils = shapeUtils[TDShapeType.Arrow]
|
|
const handleChange = utils.onHandleChange?.(initialShape, handleChanges)
|
|
|
|
// If the handle changed produced no change, bail here
|
|
if (!handleChange) return
|
|
|
|
// If nothing changes, we want these to be the same object reference as
|
|
// before. If it does change, we'll redefine this later on. And if we've
|
|
// made it this far, the shape should be a new object reference that
|
|
// incorporates the changes we've made due to the handle movement.
|
|
const next: { shape: ArrowShape; bindings: Record<string, TDBinding | undefined> } = {
|
|
shape: Utils.deepMerge(shape, handleChange),
|
|
bindings: {},
|
|
}
|
|
|
|
let draggedBinding: ArrowBinding | undefined
|
|
|
|
const draggingHandle = next.shape.handles[this.handleId]
|
|
|
|
const oppositeHandle = next.shape.handles[this.handleId === 'start' ? 'end' : 'start']
|
|
|
|
// START BINDING
|
|
// If we have a start binding shape id, the recompute the binding
|
|
// point based on the current end handle position
|
|
if (this.startBindingShapeId) {
|
|
let nextStartBinding: ArrowBinding | undefined
|
|
|
|
const startTarget = this.app.page.shapes[this.startBindingShapeId]
|
|
|
|
const startTargetUtils = TLDR.getShapeUtil(startTarget)
|
|
|
|
const center = startTargetUtils.getCenter(startTarget)
|
|
|
|
const startHandle = next.shape.handles.start
|
|
|
|
const endHandle = next.shape.handles.end
|
|
|
|
const rayPoint = Vec.add(startHandle.point, next.shape.point)
|
|
|
|
if (Vec.isEqual(rayPoint, center)) rayPoint[1]++ // Fix bug where ray and center are identical
|
|
|
|
const rayOrigin = center
|
|
|
|
const isInsideShape = startTargetUtils.hitTestPoint(startTarget, currentPoint)
|
|
|
|
const rayDirection = Vec.uni(Vec.sub(rayPoint, rayOrigin))
|
|
|
|
const hasStartBinding = this.app.getBinding(this.newStartBindingId) !== undefined
|
|
|
|
// Don't bind the start handle if both handles are inside of the target shape.
|
|
if (
|
|
!metaKey &&
|
|
!startTargetUtils.hitTestPoint(startTarget, Vec.add(next.shape.point, endHandle.point))
|
|
) {
|
|
nextStartBinding = this.findBindingPoint(
|
|
shape,
|
|
startTarget,
|
|
'start',
|
|
this.newStartBindingId,
|
|
center,
|
|
rayOrigin,
|
|
rayDirection,
|
|
isInsideShape
|
|
)
|
|
}
|
|
|
|
if (nextStartBinding && !hasStartBinding) {
|
|
// Bind the arrow's start handle to the start target
|
|
this.didBind = true
|
|
|
|
next.bindings[this.newStartBindingId] = nextStartBinding
|
|
|
|
next.shape = Utils.deepMerge(next.shape, {
|
|
handles: {
|
|
start: {
|
|
bindingId: nextStartBinding.id,
|
|
},
|
|
},
|
|
})
|
|
} else if (!nextStartBinding && hasStartBinding) {
|
|
// Remove the start binding
|
|
this.didBind = false
|
|
|
|
next.bindings[this.newStartBindingId] = undefined
|
|
|
|
next.shape = Utils.deepMerge(initialShape, {
|
|
handles: {
|
|
start: {
|
|
bindingId: undefined,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
}
|
|
|
|
// DRAGGED POINT BINDING
|
|
if (!metaKey) {
|
|
const rayOrigin = Vec.add(oppositeHandle.point, next.shape.point)
|
|
|
|
const rayPoint = Vec.add(draggingHandle.point, next.shape.point)
|
|
|
|
const rayDirection = Vec.uni(Vec.sub(rayPoint, rayOrigin))
|
|
|
|
const startPoint = Vec.add(next.shape.point!, next.shape.handles!.start.point!)
|
|
|
|
const endPoint = Vec.add(next.shape.point!, next.shape.handles!.end.point!)
|
|
|
|
const targets = this.bindableShapeIds
|
|
.map((id) => this.app.page.shapes[id])
|
|
.sort((a, b) => b.childIndex - a.childIndex)
|
|
.filter((shape) => {
|
|
if (shape.isLocked) return false
|
|
const utils = TLDR.getShapeUtil(shape)
|
|
return ![startPoint, endPoint].every((point) => utils.hitTestPoint(shape, point))
|
|
})
|
|
|
|
for (const target of targets) {
|
|
draggedBinding = this.findBindingPoint(
|
|
shape,
|
|
target,
|
|
this.handleId,
|
|
this.draggedBindingId,
|
|
rayPoint,
|
|
rayOrigin,
|
|
rayDirection,
|
|
altKey
|
|
)
|
|
|
|
if (draggedBinding) break
|
|
}
|
|
}
|
|
|
|
if (draggedBinding) {
|
|
// Create the dragged point binding
|
|
this.didBind = true
|
|
|
|
next.bindings[this.draggedBindingId] = draggedBinding
|
|
|
|
next.shape = Utils.deepMerge(next.shape, {
|
|
handles: {
|
|
[this.handleId]: {
|
|
bindingId: this.draggedBindingId,
|
|
},
|
|
},
|
|
})
|
|
} else {
|
|
// Remove the dragging point binding
|
|
this.didBind = this.didBind || false
|
|
|
|
const currentBindingId = shape.handles[this.handleId].bindingId
|
|
|
|
if (currentBindingId !== undefined) {
|
|
next.bindings[currentBindingId] = undefined
|
|
|
|
next.shape = Utils.deepMerge(next.shape, {
|
|
handles: {
|
|
[this.handleId]: {
|
|
bindingId: undefined,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
}
|
|
|
|
const change = TLDR.getShapeUtil<ArrowShape>(next.shape).onHandleChange?.(
|
|
next.shape,
|
|
next.shape.handles
|
|
)
|
|
|
|
return {
|
|
document: {
|
|
pages: {
|
|
[this.app.currentPageId]: {
|
|
shapes: {
|
|
[shape.id]: { ...next.shape, ...(change ?? {}) },
|
|
},
|
|
bindings: next.bindings,
|
|
},
|
|
},
|
|
pageStates: {
|
|
[this.app.currentPageId]: {
|
|
bindingId: next.shape.handles[handleId].bindingId,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
cancel = (): TldrawPatch | undefined => {
|
|
const { initialShape, initialBinding, newStartBindingId, draggedBindingId } = this
|
|
|
|
const currentShape = TLDR.onSessionComplete(this.app.page.shapes[initialShape.id]) as ArrowShape
|
|
|
|
const isDeleting =
|
|
this.isCreate ||
|
|
Vec.dist(currentShape.handles.start.point, currentShape.handles.end.point) < 4
|
|
|
|
const afterBindings: Record<string, TDBinding | undefined> = {}
|
|
|
|
afterBindings[draggedBindingId] = undefined
|
|
|
|
if (initialBinding) {
|
|
afterBindings[initialBinding.id] = isDeleting ? undefined : initialBinding
|
|
}
|
|
|
|
if (newStartBindingId) {
|
|
afterBindings[newStartBindingId] = undefined
|
|
}
|
|
|
|
return {
|
|
document: {
|
|
pages: {
|
|
[this.app.currentPageId]: {
|
|
shapes: {
|
|
[initialShape.id]: isDeleting ? undefined : initialShape,
|
|
},
|
|
bindings: afterBindings,
|
|
},
|
|
},
|
|
pageStates: {
|
|
[this.app.currentPageId]: {
|
|
selectedIds: isDeleting ? [] : [initialShape.id],
|
|
bindingId: undefined,
|
|
hoveredId: undefined,
|
|
editingId: undefined,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
complete = (): TldrawPatch | TldrawCommand | undefined => {
|
|
const { initialShape, initialBinding, newStartBindingId, startBindingShapeId, handleId } = this
|
|
|
|
const currentShape = TLDR.onSessionComplete(this.app.page.shapes[initialShape.id]) as ArrowShape
|
|
|
|
const currentBindingId = currentShape.handles[handleId].bindingId
|
|
|
|
const length = Vec.dist(currentShape.handles.start.point, currentShape.handles.end.point)
|
|
|
|
if (!(currentBindingId || initialBinding) && length < 4) return this.cancel()
|
|
|
|
const beforeBindings: Partial<Record<string, TDBinding>> = {}
|
|
|
|
const afterBindings: Partial<Record<string, TDBinding>> = {}
|
|
|
|
if (initialBinding) {
|
|
beforeBindings[initialBinding.id] = this.isCreate ? undefined : initialBinding
|
|
afterBindings[initialBinding.id] = undefined
|
|
}
|
|
|
|
if (currentBindingId) {
|
|
beforeBindings[currentBindingId] = undefined
|
|
afterBindings[currentBindingId] = this.app.page.bindings[currentBindingId]
|
|
}
|
|
|
|
if (startBindingShapeId) {
|
|
beforeBindings[newStartBindingId] = undefined
|
|
afterBindings[newStartBindingId] = this.app.page.bindings[newStartBindingId]
|
|
}
|
|
|
|
return {
|
|
id: 'arrow',
|
|
before: {
|
|
document: {
|
|
pages: {
|
|
[this.app.currentPageId]: {
|
|
shapes: {
|
|
[initialShape.id]: this.isCreate ? undefined : initialShape,
|
|
},
|
|
bindings: beforeBindings,
|
|
},
|
|
},
|
|
pageStates: {
|
|
[this.app.currentPageId]: {
|
|
selectedIds: this.isCreate ? [] : [initialShape.id],
|
|
bindingId: undefined,
|
|
hoveredId: undefined,
|
|
editingId: undefined,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
after: {
|
|
document: {
|
|
pages: {
|
|
[this.app.currentPageId]: {
|
|
shapes: {
|
|
[initialShape.id]: currentShape,
|
|
},
|
|
bindings: afterBindings,
|
|
},
|
|
},
|
|
pageStates: {
|
|
[this.app.currentPageId]: {
|
|
selectedIds: [initialShape.id],
|
|
bindingId: undefined,
|
|
hoveredId: undefined,
|
|
editingId: undefined,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
private findBindingPoint = (
|
|
shape: ArrowShape,
|
|
target: TDShape,
|
|
handleId: 'start' | 'end',
|
|
bindingId: string,
|
|
point: number[],
|
|
origin: number[],
|
|
direction: number[],
|
|
bindAnywhere: boolean
|
|
) => {
|
|
const util = TLDR.getShapeUtil<TDShape>(target.type)
|
|
|
|
const bindingPoint = util.getBindingPoint(
|
|
target,
|
|
shape,
|
|
point, // fix dead center bug
|
|
origin,
|
|
direction,
|
|
bindAnywhere
|
|
)
|
|
|
|
// Not all shapes will produce a binding point
|
|
if (!bindingPoint) return
|
|
|
|
return {
|
|
id: bindingId,
|
|
type: 'arrow',
|
|
fromId: shape.id,
|
|
toId: target.id,
|
|
handleId: handleId,
|
|
point: Vec.toFixed(bindingPoint.point),
|
|
distance: bindingPoint.distance,
|
|
}
|
|
}
|
|
}
|