Virtual whiteboard for sketching hand-drawn like diagrams
Refactoring in pointer down event handler, step 3 (#1888)
Michal Srb4ab4fce9981a
diff --git a/src/components/App.tsx b/src/components/App.tsxindex 1887c612d0..73c0816658 100644--- a/src/components/App.tsx+++ b/src/components/App.tsx@@ -191,6 +191,10 @@ const gesture: Gesture = {type PointerDownState = Readonly<{// The first position at which pointerDown happenedorigin: Readonly<{ x: number; y: number }>;+ // Same as "origin" but snapped to the grid, if grid is on+ originInGrid: Readonly<{ x: number; y: number }>;+ // Scrollbar checks+ scrollbars: ReturnType<typeof isOverScrollBars>;// The previous pointer positionlastCoords: { x: number; y: number };resize: {@@ -209,6 +213,22 @@ type PointerDownState = Readonly<{element: ExcalidrawElement | null;// This is determined on the initial pointer down eventwasAddedToSelection: boolean;+ // Whether selected element(s) were duplicated, might change during the+ // pointer interation+ hasBeenDuplicated: boolean;+ };+ drag: {+ // Might change during the pointer interation+ hasOccurred: boolean;+ // Might change during the pointer interation+ offset: { x: number; y: number } | null;+ };+ // We need to have these in the state so that we can unsubscribe them+ eventListeners: {+ // It's defined on the initial pointer down event+ onMove: null | ((event: PointerEvent) => void);+ // It's defined on the initial pointer down event+ onUp: null | ((event: PointerEvent) => void);};}>;@@ -1756,12 +1776,12 @@ class App extends React.Component<ExcalidrawProps, AppState> {if (isHoldingSpace || isPanning || isDraggingScrollBar) {return;}- const {- isOverHorizontalScrollBar,- isOverVerticalScrollBar,- } = isOverScrollBars(currentScrollBars, event.clientX, event.clientY);- const isOverScrollBar =- isOverVerticalScrollBar || isOverHorizontalScrollBar;+ const isPointerOverScrollBars = isOverScrollBars(+ currentScrollBars,+ event.clientX,+ event.clientY,+ );+ const isOverScrollBar = isPointerOverScrollBars.isOverEither;if (!this.state.draggingElement && !this.state.multiElement) {if (isOverScrollBar) {resetCursor();@@ -1967,57 +1987,14 @@ class App extends React.Component<ExcalidrawProps, AppState> {return;}- // Handle scrollbars dragging- const isOverScrollBarsNow = isOverScrollBars(- currentScrollBars,- event.clientX,- event.clientY,- );- const {- isOverHorizontalScrollBar,- isOverVerticalScrollBar,- } = isOverScrollBarsNow;-- const origin = viewportCoordsToSceneCoords(- event,- this.state,- this.canvas,- window.devicePixelRatio,- );-// State for the duration of a pointer interaction, which starts with a// pointerDown event, ends with a pointerUp event (or another pointerDown)- const pointerDownState: PointerDownState = {- origin,- // we need to duplicate because we'll be updating this state- lastCoords: { ...origin },- resize: {- handle: false as ReturnType<typeof resizeTest>,- isResizing: false,- offset: { x: 0, y: 0 },- arrowDirection: "origin",- },- hit: {- element: null,- wasAddedToSelection: false,- },- };+ const pointerDownState = this.initialPointerDownState(event);- if (- this.handleDraggingScrollBar(event, pointerDownState, isOverScrollBarsNow)- ) {+ if (this.handleDraggingScrollBar(event, pointerDownState)) {return;}- const [originGridX, originGridY] = getGridPoint(- pointerDownState.origin.x,- pointerDownState.origin.y,- this.state.gridSize,- );-- let draggingOccurred = false;- let dragOffsetXY: [number, number] | null = null;-this.clearSelectionIfNotUsingSelection();if (this.handleSelectionOnPointerDown(event, pointerDownState)) {@@ -2044,27 +2021,223 @@ class App extends React.Component<ExcalidrawProps, AppState> {);}- let selectedElementWasDuplicated = false;+ const onPointerMove = this.onPointerMoveFromPointerDownHandler(+ pointerDownState,+ );++ const onPointerUp = this.onPointerUpFromPointerDownHandler(+ pointerDownState,+ );++ lastPointerUp = onPointerUp;++ window.addEventListener(EVENT.POINTER_MOVE, onPointerMove);+ window.addEventListener(EVENT.POINTER_UP, onPointerUp);+ pointerDownState.eventListeners.onMove = onPointerMove;+ pointerDownState.eventListeners.onUp = onPointerUp;+ };++ private maybeOpenContextMenuAfterPointerDownOnTouchDevices = (+ event: React.PointerEvent<HTMLCanvasElement>,+ ): void => {+ // deal with opening context menu on touch devices+ if (event.pointerType === "touch") {+ touchMoving = false;++ // open the context menu with the first touch's clientX and clientY+ // if the touch is not moving+ touchTimeout = window.setTimeout(() => {+ if (!touchMoving) {+ this.openContextMenu({+ clientX: event.clientX,+ clientY: event.clientY,+ });+ }+ }, TOUCH_CTX_MENU_TIMEOUT);+ }+ };++ private maybeCleanupAfterMissingPointerUp(+ event: React.PointerEvent<HTMLCanvasElement>,+ ): void {+ if (lastPointerUp !== null) {+ // Unfortunately, sometimes we don't get a pointerup after a pointerdown,+ // this can happen when a contextual menu or alert is triggered. In order to avoid+ // being in a weird state, we clean up on the next pointerdown+ lastPointerUp(event);+ }+ }++ // Returns whether the event is a panning+ private handleCanvasPanUsingWheelOrSpaceDrag = (+ event: React.PointerEvent<HTMLCanvasElement>,+ ): boolean => {+ if (+ !(+ gesture.pointers.size === 0 &&+ (event.button === POINTER_BUTTON.WHEEL ||+ (event.button === POINTER_BUTTON.MAIN && isHoldingSpace))+ )+ ) {+ return false;+ }+ isPanning = true;++ let nextPastePrevented = false;+ const isLinux = /Linux/.test(window.navigator.platform);+ document.documentElement.style.cursor = CURSOR_TYPE.GRABBING;+ let { clientX: lastX, clientY: lastY } = event;const onPointerMove = withBatchedUpdates((event: PointerEvent) => {- // We need to initialize dragOffsetXY only after we've updated- // `state.selectedElementIds` on pointerDown. Doing it here in pointerMove- // event handler should hopefully ensure we're already working with- // the updated state.- if (dragOffsetXY === null) {- dragOffsetXY = getDragOffsetXY(- getSelectedElements(globalSceneState.getElements(), this.state),- pointerDownState.origin.x,- pointerDownState.origin.y,- );+ const deltaX = lastX - event.clientX;+ const deltaY = lastY - event.clientY;+ lastX = event.clientX;+ lastY = event.clientY;++ /*+ * Prevent paste event if we move while middle clicking on Linux.+ * See issue #1383.+ */+ if (+ isLinux &&+ !nextPastePrevented &&+ (Math.abs(deltaX) > 1 || Math.abs(deltaY) > 1)+ ) {+ nextPastePrevented = true;++ /* Prevent the next paste event */+ const preventNextPaste = (event: ClipboardEvent) => {+ document.body.removeEventListener(EVENT.PASTE, preventNextPaste);+ event.stopPropagation();+ };++ /*+ * Reenable next paste in case of disabled middle click paste for+ * any reason:+ * - rigth click paste+ * - empty clipboard+ */+ const enableNextPaste = () => {+ setTimeout(() => {+ document.body.removeEventListener(EVENT.PASTE, preventNextPaste);+ window.removeEventListener(EVENT.POINTER_UP, enableNextPaste);+ }, 100);+ };++ document.body.addEventListener(EVENT.PASTE, preventNextPaste);+ window.addEventListener(EVENT.POINTER_UP, enableNextPaste);}+ this.setState({+ scrollX: normalizeScroll(this.state.scrollX - deltaX / this.state.zoom),+ scrollY: normalizeScroll(this.state.scrollY - deltaY / this.state.zoom),+ });+ });+ const teardown = withBatchedUpdates(+ (lastPointerUp = () => {+ lastPointerUp = null;+ isPanning = false;+ if (!isHoldingSpace) {+ setCursorForShape(this.state.elementType);+ }+ this.setState({+ cursorButton: "up",+ });+ this.savePointer(event.clientX, event.clientY, "up");+ window.removeEventListener(EVENT.POINTER_MOVE, onPointerMove);+ window.removeEventListener(EVENT.POINTER_UP, teardown);+ window.removeEventListener(EVENT.BLUR, teardown);+ }),+ );+ window.addEventListener(EVENT.BLUR, teardown);+ window.addEventListener(EVENT.POINTER_MOVE, onPointerMove, {+ passive: true,+ });+ window.addEventListener(EVENT.POINTER_UP, teardown);+ return true;+ };++ private updateGestureOnPointerDown(+ event: React.PointerEvent<HTMLCanvasElement>,+ ): void {+ gesture.pointers.set(event.pointerId, {+ x: event.clientX,+ y: event.clientY,+ });++ if (gesture.pointers.size === 2) {+ gesture.lastCenter = getCenter(gesture.pointers);+ gesture.initialScale = this.state.zoom;+ gesture.initialDistance = getDistance(+ Array.from(gesture.pointers.values()),+ );+ }+ }++ private initialPointerDownState(+ event: React.PointerEvent<HTMLCanvasElement>,+ ): PointerDownState {+ const origin = viewportCoordsToSceneCoords(+ event,+ this.state,+ this.canvas,+ window.devicePixelRatio,+ );++ return {+ origin,+ originInGrid: tupleToCoors(+ getGridPoint(origin.x, origin.y, this.state.gridSize),+ ),+ scrollbars: isOverScrollBars(+ currentScrollBars,+ event.clientX,+ event.clientY,+ ),+ // we need to duplicate because we'll be updating this state+ lastCoords: { ...origin },+ resize: {+ handle: false as ReturnType<typeof resizeTest>,+ isResizing: false,+ offset: { x: 0, y: 0 },+ arrowDirection: "origin",+ },+ hit: {+ element: null,+ wasAddedToSelection: false,+ hasBeenDuplicated: false,+ },+ drag: {+ hasOccurred: false,+ offset: null,+ },+ eventListeners: {+ onMove: null,+ onUp: null,+ },+ };+ }++ // Returns whether the event is a dragging a scrollbar+ private handleDraggingScrollBar(+ event: React.PointerEvent<HTMLCanvasElement>,+ pointerDownState: PointerDownState,+ ): boolean {+ if (+ !(pointerDownState.scrollbars.isOverEither && !this.state.multiElement)+ ) {+ return false;+ }+ isDraggingScrollBar = true;+ pointerDownState.lastCoords.x = event.clientX;+ pointerDownState.lastCoords.y = event.clientY;+ const onPointerMove = withBatchedUpdates((event: PointerEvent) => {const target = event.target;if (!(target instanceof HTMLElement)) {return;}- if (isOverHorizontalScrollBar) {+ if (pointerDownState.scrollbars.isOverHorizontal) {const x = event.clientX;const dx = x - pointerDownState.lastCoords.x;this.setState({@@ -2074,629 +2247,359 @@ class App extends React.Component<ExcalidrawProps, AppState> {return;}- if (isOverVerticalScrollBar) {+ if (pointerDownState.scrollbars.isOverVertical) {const y = event.clientY;const dy = y - pointerDownState.lastCoords.y;this.setState({scrollY: normalizeScroll(this.state.scrollY - dy / this.state.zoom),});pointerDownState.lastCoords.y = y;- return;}+ });- const { x, y } = viewportCoordsToSceneCoords(- event,- this.state,- this.canvas,- window.devicePixelRatio,- );- const [gridX, gridY] = getGridPoint(x, y, this.state.gridSize);+ const onPointerUp = withBatchedUpdates(() => {+ isDraggingScrollBar = false;+ setCursorForShape(this.state.elementType);+ lastPointerUp = null;+ this.setState({+ cursorButton: "up",+ });+ this.savePointer(event.clientX, event.clientY, "up");+ window.removeEventListener(EVENT.POINTER_MOVE, onPointerMove);+ window.removeEventListener(EVENT.POINTER_UP, onPointerUp);+ });- // for arrows/lines, don't start dragging until a given threshold- // to ensure we don't create a 2-point arrow by mistake when- // user clicks mouse in a way that it moves a tiny bit (thus- // triggering pointermove)- if (- !draggingOccurred &&- (this.state.elementType === "arrow" ||- this.state.elementType === "line")- ) {- if (- distance2d(- x,- y,- pointerDownState.origin.x,- pointerDownState.origin.y,- ) < DRAGGING_THRESHOLD- ) {- return;- }- }+ lastPointerUp = onPointerUp;- if (pointerDownState.resize.isResizing) {- const selectedElements = getSelectedElements(- globalSceneState.getElements(),+ window.addEventListener(EVENT.POINTER_MOVE, onPointerMove);+ window.addEventListener(EVENT.POINTER_UP, onPointerUp);+ return true;+ }++ private clearSelectionIfNotUsingSelection = (): void => {+ if (this.state.elementType !== "selection") {+ this.setState({+ selectedElementIds: {},+ selectedGroupIds: {},+ editingGroupId: null,+ });+ }+ };++ // Returns whether the pointer event has been completely handled+ private handleSelectionOnPointerDown = (+ event: React.PointerEvent<HTMLCanvasElement>,+ pointerDownState: PointerDownState,+ ): boolean => {+ if (this.state.elementType === "selection") {+ const elements = globalSceneState.getElements();+ const selectedElements = getSelectedElements(elements, this.state);+ if (selectedElements.length === 1 && !this.state.editingLinearElement) {+ const elementWithResizeHandler = getElementWithResizeHandler(+ elements,this.state,+ pointerDownState.origin.x,+ pointerDownState.origin.y,+ this.state.zoom,+ event.pointerType,);- const resizeHandle = pointerDownState.resize.handle;- this.setState({- // TODO: rename this state field to "isScaling" to distinguish- // it from the generic "isResizing" which includes scaling and- // rotating- isResizing: resizeHandle && resizeHandle !== "rotation",- isRotating: resizeHandle === "rotation",+ if (elementWithResizeHandler != null) {+ this.setState({+ resizingElement: elementWithResizeHandler.element,+ });+ pointerDownState.resize.handle =+ elementWithResizeHandler.resizeHandle;+ }+ } else if (selectedElements.length > 1) {+ pointerDownState.resize.handle = getResizeHandlerFromCoords(+ getCommonBounds(selectedElements),+ pointerDownState.origin.x,+ pointerDownState.origin.y,+ this.state.zoom,+ event.pointerType,+ );+ }+ if (pointerDownState.resize.handle) {+ document.documentElement.style.cursor = getCursorForResizingElement({+ resizeHandle: pointerDownState.resize.handle,});- const [resizeX, resizeY] = getGridPoint(- x - pointerDownState.resize.offset.x,- y - pointerDownState.resize.offset.y,- this.state.gridSize,+ pointerDownState.resize.isResizing = true;+ pointerDownState.resize.offset = tupleToCoors(+ getResizeOffsetXY(+ pointerDownState.resize.handle,+ selectedElements,+ pointerDownState.origin.x,+ pointerDownState.origin.y,+ ),);if (- resizeElements(- resizeHandle,- (newResizeHandle) => {- pointerDownState.resize.handle = newResizeHandle;- },- selectedElements,- pointerDownState.resize.arrowDirection,- getRotateWithDiscreteAngleKey(event),- getResizeWithSidesSameLengthKey(event),- getResizeCenterPointKey(event),- resizeX,- resizeY,- )+ selectedElements.length === 1 &&+ isLinearElement(selectedElements[0]) &&+ selectedElements[0].points.length === 2) {- return;+ pointerDownState.resize.arrowDirection = getResizeArrowDirection(+ pointerDownState.resize.handle,+ selectedElements[0],+ );}- }-- if (this.state.editingLinearElement) {- const didDrag = LinearElementEditor.handlePointDragging(- this.state,- (appState) => this.setState(appState),- x,- y,- pointerDownState.lastCoords.x,- pointerDownState.lastCoords.y,- );-- if (didDrag) {- pointerDownState.lastCoords.x = x;- pointerDownState.lastCoords.y = y;- return;+ } else {+ if (this.state.editingLinearElement) {+ const ret = LinearElementEditor.handlePointerDown(+ event,+ this.state,+ (appState) => this.setState(appState),+ history,+ pointerDownState.origin.x,+ pointerDownState.origin.y,+ );+ if (ret.hitElement) {+ pointerDownState.hit.element = ret.hitElement;+ }+ if (ret.didAddPoint) {+ return true;+ }}- }- const hitElement = pointerDownState.hit.element;- if (hitElement && this.state.selectedElementIds[hitElement.id]) {- // Marking that click was used for dragging to check- // if elements should be deselected on pointerup- draggingOccurred = true;- const selectedElements = getSelectedElements(- globalSceneState.getElements(),- this.state,- );- if (selectedElements.length > 0) {- const [dragX, dragY] = getGridPoint(- x - dragOffsetXY[0],- y - dragOffsetXY[1],- this.state.gridSize,+ // hitElement may already be set above, so check first+ pointerDownState.hit.element =+ pointerDownState.hit.element ??+ getElementAtPosition(+ elements,+ this.state,+ pointerDownState.origin.x,+ pointerDownState.origin.y,+ this.state.zoom,);- dragSelectedElements(selectedElements, dragX, dragY);-- // We duplicate the selected element if alt is pressed on pointer move- if (event.altKey && !selectedElementWasDuplicated) {- // Move the currently selected elements to the top of the z index stack, and- // put the duplicates where the selected elements used to be.- // (the origin point where the dragging started)- selectedElementWasDuplicated = true;+ this.maybeClearSelectionWhenHittingElement(+ event,+ pointerDownState.hit.element,+ );- const nextElements = [];- const elementsToAppend = [];- const groupIdMap = new Map();- for (const element of globalSceneState.getElementsIncludingDeleted()) {- if (- this.state.selectedElementIds[element.id] ||- // case: the state.selectedElementIds might not have been- // updated yet by the time this mousemove event is fired- (element.id === hitElement.id &&- pointerDownState.hit.wasAddedToSelection)- ) {- const duplicatedElement = duplicateElement(- this.state.editingGroupId,- groupIdMap,- element,- );- const [originDragX, originDragY] = getGridPoint(- pointerDownState.origin.x - dragOffsetXY[0],- pointerDownState.origin.y - dragOffsetXY[1],- this.state.gridSize,- );- mutateElement(duplicatedElement, {- x: duplicatedElement.x + (originDragX - dragX),- y: duplicatedElement.y + (originDragY - dragY),- });- nextElements.push(duplicatedElement);- elementsToAppend.push(element);- } else {- nextElements.push(element);- }+ // If we click on something+ const hitElement = pointerDownState.hit.element;+ if (hitElement != null) {+ // deselect if item is selected+ // if shift is not clicked, this will always return true+ // otherwise, it will trigger selection based on current+ // state of the box+ if (!this.state.selectedElementIds[hitElement.id]) {+ // if we are currently editing a group, treat all selections outside of the group+ // as exiting editing mode.+ if (+ this.state.editingGroupId &&+ !isElementInGroup(hitElement, this.state.editingGroupId)+ ) {+ this.setState({+ selectedElementIds: {},+ selectedGroupIds: {},+ editingGroupId: null,+ });+ return true;}- globalSceneState.replaceAllElements([- ...nextElements,- ...elementsToAppend,- ]);+ this.setState((prevState) => {+ return selectGroupsForSelectedElements(+ {+ ...prevState,+ selectedElementIds: {+ ...prevState.selectedElementIds,+ [hitElement!.id]: true,+ },+ },+ globalSceneState.getElements(),+ );+ });+ // TODO: this is strange...+ globalSceneState.replaceAllElements(+ globalSceneState.getElementsIncludingDeleted(),+ );+ pointerDownState.hit.wasAddedToSelection = true;}- return;}- }- // It is very important to read this.state within each move event,- // otherwise we would read a stale one!- const draggingElement = this.state.draggingElement;- if (!draggingElement) {- return;+ const { selectedElementIds } = this.state;+ this.setState({+ previousSelectedElementIds: selectedElementIds,+ });}+ }+ return false;+ };- if (isLinearElement(draggingElement)) {- draggingOccurred = true;- const points = draggingElement.points;- let dx: number;- let dy: number;- if (draggingElement.type === "draw") {- dx = x - draggingElement.x;- dy = y - draggingElement.y;- } else {- dx = gridX - draggingElement.x;- dy = gridY - draggingElement.y;- }-- if (getRotateWithDiscreteAngleKey(event) && points.length === 2) {- ({ width: dx, height: dy } = getPerfectElementSize(- this.state.elementType,- dx,- dy,- ));- }-- if (points.length === 1) {- mutateElement(draggingElement, { points: [...points, [dx, dy]] });- } else if (points.length > 1) {- if (draggingElement.type === "draw") {- mutateElement(draggingElement, {- points: simplify([...(points as Point[]), [dx, dy]], 0.7),- });- } else {- mutateElement(draggingElement, {- points: [...points.slice(0, -1), [dx, dy]],- });- }- }- } else if (draggingElement.type === "selection") {- dragNewElement(- draggingElement,- this.state.elementType,- pointerDownState.origin.x,- pointerDownState.origin.y,- x,- y,- distance(pointerDownState.origin.x, x),- distance(pointerDownState.origin.y, y),- getResizeWithSidesSameLengthKey(event),- getResizeCenterPointKey(event),- );- } else {- dragNewElement(- draggingElement,- this.state.elementType,- originGridX,- originGridY,- gridX,- gridY,- distance(originGridX, gridX),- distance(originGridY, gridY),- getResizeWithSidesSameLengthKey(event),- getResizeCenterPointKey(event),- );- }+ private handleTextOnPointerDown = (+ event: React.PointerEvent<HTMLCanvasElement>,+ pointerDownState: PointerDownState,+ ): void => {+ // if we're currently still editing text, clicking outside+ // should only finalize it, not create another (irrespective+ // of state.elementLocked)+ if (this.state.editingElement?.type === "text") {+ return;+ }- if (this.state.elementType === "selection") {- const elements = globalSceneState.getElements();- if (!event.shiftKey && isSomeElementSelected(elements, this.state)) {- this.setState({- selectedElementIds: {},- selectedGroupIds: {},- editingGroupId: null,- });- }- const elementsWithinSelection = getElementsWithinSelection(- elements,- draggingElement,- );- this.setState((prevState) =>- selectGroupsForSelectedElements(- {- ...prevState,- selectedElementIds: {- ...prevState.selectedElementIds,- ...elementsWithinSelection.reduce((map, element) => {- map[element.id] = true;- return map;- }, {} as any),- },- },- globalSceneState.getElements(),- ),- );- }+ this.startTextEditing({+ sceneX: pointerDownState.origin.x,+ sceneY: pointerDownState.origin.y,+ insertAtParentCenter: !event.altKey,});- const onPointerUp = withBatchedUpdates((childEvent: PointerEvent) => {- const {- draggingElement,- resizingElement,- multiElement,- elementType,- elementLocked,- } = this.state;-+ resetCursor();+ if (!this.state.elementLocked) {this.setState({- isResizing: false,- isRotating: false,- resizingElement: null,- selectionElement: null,- cursorButton: "up",- // text elements are reset on finalize, and resetting on pointerup- // may cause issues with double taps- editingElement:- multiElement || isTextElement(this.state.editingElement)- ? this.state.editingElement- : null,+ elementType: "selection",});+ }+ };- this.savePointer(childEvent.clientX, childEvent.clientY, "up");-- // if moving start/end point towards start/end point within threshold,- // close the loop- if (this.state.editingLinearElement) {- const editingLinearElement = LinearElementEditor.handlePointerUp(- this.state.editingLinearElement,- );- if (editingLinearElement !== this.state.editingLinearElement) {- this.setState({ editingLinearElement });- }- }-- lastPointerUp = null;-- window.removeEventListener(EVENT.POINTER_MOVE, onPointerMove);- window.removeEventListener(EVENT.POINTER_UP, onPointerUp);-- if (draggingElement?.type === "draw") {- this.actionManager.executeAction(actionFinalize);- return;- }- if (isLinearElement(draggingElement)) {- if (draggingElement!.points.length > 1) {- history.resumeRecording();- }- if (!draggingOccurred && draggingElement && !multiElement) {- const { x, y } = viewportCoordsToSceneCoords(- childEvent,- this.state,- this.canvas,- window.devicePixelRatio,- );- mutateElement(draggingElement, {- points: [- ...draggingElement.points,- [x - draggingElement.x, y - draggingElement.y],- ],- });- this.setState({- multiElement: draggingElement,- editingElement: this.state.draggingElement,- });- } else if (draggingOccurred && !multiElement) {- if (!elementLocked) {- resetCursor();- this.setState((prevState) => ({- draggingElement: null,- elementType: "selection",- selectedElementIds: {- ...prevState.selectedElementIds,- [this.state.draggingElement!.id]: true,- },- }));- } else {- this.setState((prevState) => ({- draggingElement: null,- selectedElementIds: {- ...prevState.selectedElementIds,- [this.state.draggingElement!.id]: true,- },- }));- }- }- return;- }+ private handleLinearElementOnPointerDown = (+ event: React.PointerEvent<HTMLCanvasElement>,+ elementType: "draw" | "line" | "arrow",+ pointerDownState: PointerDownState,+ ): void => {+ if (this.state.multiElement) {+ const { multiElement } = this.state;- if (- elementType !== "selection" &&- draggingElement &&- isInvisiblySmallElement(draggingElement)- ) {- // remove invisible element which was added in onPointerDown- globalSceneState.replaceAllElements(- globalSceneState.getElementsIncludingDeleted().slice(0, -1),- );- this.setState({- draggingElement: null,+ // finalize if completing a loop+ if (multiElement.type === "line" && isPathALoop(multiElement.points)) {+ mutateElement(multiElement, {+ lastCommittedPoint:+ multiElement.points[multiElement.points.length - 1],});+ this.actionManager.executeAction(actionFinalize);return;}- if (draggingElement) {- mutateElement(- draggingElement,- getNormalizedDimensions(draggingElement),- );- }-- if (resizingElement) {- history.resumeRecording();- }-- if (resizingElement && isInvisiblySmallElement(resizingElement)) {- globalSceneState.replaceAllElements(- globalSceneState- .getElementsIncludingDeleted()- .filter((el) => el.id !== resizingElement.id),- );- }+ const { x: rx, y: ry, lastCommittedPoint } = multiElement;- // If click occurred on already selected element- // it is needed to remove selection from other elements- // or if SHIFT or META key pressed remove selection- // from hitted element- //- // If click occurred and elements were dragged or some element- // was added to selection (on pointerdown phase) we need to keep- // selection unchanged- const hitElement = pointerDownState.hit.element;+ // clicking inside commit zone → finalize arrowif (- getSelectedGroupIds(this.state).length === 0 &&- hitElement &&- !draggingOccurred &&- !pointerDownState.hit.wasAddedToSelection+ multiElement.points.length > 1 &&+ lastCommittedPoint &&+ distance2d(+ pointerDownState.origin.x - rx,+ pointerDownState.origin.y - ry,+ lastCommittedPoint[0],+ lastCommittedPoint[1],+ ) < LINE_CONFIRM_THRESHOLD) {- if (childEvent.shiftKey) {- this.setState((prevState) => ({- selectedElementIds: {- ...prevState.selectedElementIds,- [hitElement!.id]: false,- },- }));- } else {- this.setState((_prevState) => ({- selectedElementIds: { [hitElement!.id]: true },- }));- }- }-- if (draggingElement === null) {- // if no element is clicked, clear the selection and redraw- this.setState({- selectedElementIds: {},- selectedGroupIds: {},- editingGroupId: null,- });+ this.actionManager.executeAction(actionFinalize);return;}- if (!elementLocked) {- this.setState((prevState) => ({- selectedElementIds: {- ...prevState.selectedElementIds,- [draggingElement.id]: true,- },- }));- }-- if (- elementType !== "selection" ||- isSomeElementSelected(globalSceneState.getElements(), this.state)- ) {- history.resumeRecording();- }-- if (!elementLocked) {- resetCursor();- this.setState({- draggingElement: null,- elementType: "selection",- });- } else {- this.setState({- draggingElement: null,- });- }- });-- lastPointerUp = onPointerUp;-- window.addEventListener(EVENT.POINTER_MOVE, onPointerMove);- window.addEventListener(EVENT.POINTER_UP, onPointerUp);- };-- private maybeOpenContextMenuAfterPointerDownOnTouchDevices = (- event: React.PointerEvent<HTMLCanvasElement>,- ): void => {- // deal with opening context menu on touch devices- if (event.pointerType === "touch") {- touchMoving = false;-- // open the context menu with the first touch's clientX and clientY- // if the touch is not moving- touchTimeout = window.setTimeout(() => {- if (!touchMoving) {- this.openContextMenu({- clientX: event.clientX,- clientY: event.clientY,- });- }- }, TOUCH_CTX_MENU_TIMEOUT);- }- };-- private maybeCleanupAfterMissingPointerUp(- event: React.PointerEvent<HTMLCanvasElement>,- ): void {- if (lastPointerUp !== null) {- // Unfortunately, sometimes we don't get a pointerup after a pointerdown,- // this can happen when a contextual menu or alert is triggered. In order to avoid- // being in a weird state, we clean up on the next pointerdown- lastPointerUp(event);- }- }-- // Returns whether the event is a panning- private handleCanvasPanUsingWheelOrSpaceDrag = (- event: React.PointerEvent<HTMLCanvasElement>,- ): boolean => {- if (- !(- gesture.pointers.size === 0 &&- (event.button === POINTER_BUTTON.WHEEL ||- (event.button === POINTER_BUTTON.MAIN && isHoldingSpace))- )- ) {- return false;- }- isPanning = true;-- let nextPastePrevented = false;- const isLinux = /Linux/.test(window.navigator.platform);-- document.documentElement.style.cursor = CURSOR_TYPE.GRABBING;- let { clientX: lastX, clientY: lastY } = event;- const onPointerMove = withBatchedUpdates((event: PointerEvent) => {- const deltaX = lastX - event.clientX;- const deltaY = lastY - event.clientY;- lastX = event.clientX;- lastY = event.clientY;-- /*- * Prevent paste event if we move while middle clicking on Linux.- * See issue #1383.- */- if (- isLinux &&- !nextPastePrevented &&- (Math.abs(deltaX) > 1 || Math.abs(deltaY) > 1)- ) {- nextPastePrevented = true;-- /* Prevent the next paste event */- const preventNextPaste = (event: ClipboardEvent) => {- document.body.removeEventListener(EVENT.PASTE, preventNextPaste);- event.stopPropagation();- };-- /*- * Reenable next paste in case of disabled middle click paste for- * any reason:- * - rigth click paste- * - empty clipboard- */- const enableNextPaste = () => {- setTimeout(() => {- document.body.removeEventListener(EVENT.PASTE, preventNextPaste);- window.removeEventListener(EVENT.POINTER_UP, enableNextPaste);- }, 100);- };-- document.body.addEventListener(EVENT.PASTE, preventNextPaste);- window.addEventListener(EVENT.POINTER_UP, enableNextPaste);- }-- this.setState({- scrollX: normalizeScroll(this.state.scrollX - deltaX / this.state.zoom),- scrollY: normalizeScroll(this.state.scrollY - deltaY / this.state.zoom),+ this.setState((prevState) => ({+ selectedElementIds: {+ ...prevState.selectedElementIds,+ [multiElement.id]: true,+ },+ }));+ // clicking outside commit zone → update reference for last committed+ // point+ mutateElement(multiElement, {+ lastCommittedPoint: multiElement.points[multiElement.points.length - 1],});- });- const teardown = withBatchedUpdates(- (lastPointerUp = () => {- lastPointerUp = null;- isPanning = false;- if (!isHoldingSpace) {- setCursorForShape(this.state.elementType);- }- this.setState({- cursorButton: "up",- });- this.savePointer(event.clientX, event.clientY, "up");- window.removeEventListener(EVENT.POINTER_MOVE, onPointerMove);- window.removeEventListener(EVENT.POINTER_UP, teardown);- window.removeEventListener(EVENT.BLUR, teardown);- }),- );- window.addEventListener(EVENT.BLUR, teardown);- window.addEventListener(EVENT.POINTER_MOVE, onPointerMove, {- passive: true,- });- window.addEventListener(EVENT.POINTER_UP, teardown);- return true;+ document.documentElement.style.cursor = CURSOR_TYPE.POINTER;+ } else {+ const [gridX, gridY] = getGridPoint(+ pointerDownState.origin.x,+ pointerDownState.origin.y,+ elementType === "draw" ? null : this.state.gridSize,+ );+ const element = newLinearElement({+ type: elementType,+ x: gridX,+ y: gridY,+ strokeColor: this.state.currentItemStrokeColor,+ backgroundColor: this.state.currentItemBackgroundColor,+ fillStyle: this.state.currentItemFillStyle,+ strokeWidth: this.state.currentItemStrokeWidth,+ strokeStyle: this.state.currentItemStrokeStyle,+ roughness: this.state.currentItemRoughness,+ opacity: this.state.currentItemOpacity,+ });+ this.setState((prevState) => ({+ selectedElementIds: {+ ...prevState.selectedElementIds,+ [element.id]: false,+ },+ }));+ mutateElement(element, {+ points: [...element.points, [0, 0]],+ });+ globalSceneState.replaceAllElements([+ ...globalSceneState.getElementsIncludingDeleted(),+ element,+ ]);+ this.setState({+ draggingElement: element,+ editingElement: element,+ });+ }};- private updateGestureOnPointerDown(- event: React.PointerEvent<HTMLCanvasElement>,- ): void {- gesture.pointers.set(event.pointerId, {- x: event.clientX,- y: event.clientY,+ private createGenericElementOnPointerDown = (+ elementType: ExcalidrawGenericElement["type"],+ pointerDownState: PointerDownState,+ ): void => {+ const [gridX, gridY] = getGridPoint(+ pointerDownState.origin.x,+ pointerDownState.origin.y,+ this.state.gridSize,+ );+ const element = newElement({+ type: elementType,+ x: gridX,+ y: gridY,+ strokeColor: this.state.currentItemStrokeColor,+ backgroundColor: this.state.currentItemBackgroundColor,+ fillStyle: this.state.currentItemFillStyle,+ strokeWidth: this.state.currentItemStrokeWidth,+ strokeStyle: this.state.currentItemStrokeStyle,+ roughness: this.state.currentItemRoughness,+ opacity: this.state.currentItemOpacity,});- if (gesture.pointers.size === 2) {- gesture.lastCenter = getCenter(gesture.pointers);- gesture.initialScale = this.state.zoom;- gesture.initialDistance = getDistance(- Array.from(gesture.pointers.values()),- );+ if (element.type === "selection") {+ this.setState({+ selectionElement: element,+ draggingElement: element,+ });+ } else {+ globalSceneState.replaceAllElements([+ ...globalSceneState.getElementsIncludingDeleted(),+ element,+ ]);+ this.setState({+ multiElement: null,+ draggingElement: element,+ editingElement: element,+ });}- }+ };- // Returns whether the event is a dragging a scrollbar- private handleDraggingScrollBar(- event: React.PointerEvent<HTMLCanvasElement>,+ private onPointerMoveFromPointerDownHandler(pointerDownState: PointerDownState,- {- isOverHorizontalScrollBar,- isOverVerticalScrollBar,- }: {- isOverHorizontalScrollBar: boolean;- isOverVerticalScrollBar: boolean;- },- ): boolean {- if (- !(- (isOverHorizontalScrollBar || isOverVerticalScrollBar) &&- !this.state.multiElement- )- ) {- return false;- }- isDraggingScrollBar = true;- pointerDownState.lastCoords.x = event.clientX;- pointerDownState.lastCoords.y = event.clientY;- const onPointerMove = withBatchedUpdates((event: PointerEvent) => {+ ): (event: PointerEvent) => void {+ return withBatchedUpdates((event: PointerEvent) => {+ // We need to initialize dragOffsetXY only after we've updated+ // `state.selectedElementIds` on pointerDown. Doing it here in pointerMove+ // event handler should hopefully ensure we're already working with+ // the updated state.+ if (pointerDownState.drag.offset === null) {+ pointerDownState.drag.offset = tupleToCoors(+ getDragOffsetXY(+ getSelectedElements(globalSceneState.getElements(), this.state),+ pointerDownState.origin.x,+ pointerDownState.origin.y,+ ),+ );+ }+const target = event.target;if (!(target instanceof HTMLElement)) {return;}- if (isOverHorizontalScrollBar) {+ if (pointerDownState.scrollbars.isOverHorizontal) {const x = event.clientX;const dx = x - pointerDownState.lastCoords.x;this.setState({@@ -2706,334 +2609,470 @@ class App extends React.Component<ExcalidrawProps, AppState> {return;}- if (isOverVerticalScrollBar) {+ if (pointerDownState.scrollbars.isOverVertical) {const y = event.clientY;const dy = y - pointerDownState.lastCoords.y;this.setState({scrollY: normalizeScroll(this.state.scrollY - dy / this.state.zoom),});pointerDownState.lastCoords.y = y;+ return;}- });- const onPointerUp = withBatchedUpdates(() => {- isDraggingScrollBar = false;- setCursorForShape(this.state.elementType);- lastPointerUp = null;- this.setState({- cursorButton: "up",- });- this.savePointer(event.clientX, event.clientY, "up");- window.removeEventListener(EVENT.POINTER_MOVE, onPointerMove);- window.removeEventListener(EVENT.POINTER_UP, onPointerUp);- });+ const { x, y } = viewportCoordsToSceneCoords(+ event,+ this.state,+ this.canvas,+ window.devicePixelRatio,+ );+ const [gridX, gridY] = getGridPoint(x, y, this.state.gridSize);- lastPointerUp = onPointerUp;+ // for arrows/lines, don't start dragging until a given threshold+ // to ensure we don't create a 2-point arrow by mistake when+ // user clicks mouse in a way that it moves a tiny bit (thus+ // triggering pointermove)+ if (+ !pointerDownState.drag.hasOccurred &&+ (this.state.elementType === "arrow" ||+ this.state.elementType === "line")+ ) {+ if (+ distance2d(+ x,+ y,+ pointerDownState.origin.x,+ pointerDownState.origin.y,+ ) < DRAGGING_THRESHOLD+ ) {+ return;+ }+ }++ if (pointerDownState.resize.isResizing) {+ const selectedElements = getSelectedElements(+ globalSceneState.getElements(),+ this.state,+ );+ const resizeHandle = pointerDownState.resize.handle;+ this.setState({+ // TODO: rename this state field to "isScaling" to distinguish+ // it from the generic "isResizing" which includes scaling and+ // rotating+ isResizing: resizeHandle && resizeHandle !== "rotation",+ isRotating: resizeHandle === "rotation",+ });+ const [resizeX, resizeY] = getGridPoint(+ x - pointerDownState.resize.offset.x,+ y - pointerDownState.resize.offset.y,+ this.state.gridSize,+ );+ if (+ resizeElements(+ resizeHandle,+ (newResizeHandle) => {+ pointerDownState.resize.handle = newResizeHandle;+ },+ selectedElements,+ pointerDownState.resize.arrowDirection,+ getRotateWithDiscreteAngleKey(event),+ getResizeWithSidesSameLengthKey(event),+ getResizeCenterPointKey(event),+ resizeX,+ resizeY,+ )+ ) {+ return;+ }+ }++ if (this.state.editingLinearElement) {+ const didDrag = LinearElementEditor.handlePointDragging(+ this.state,+ (appState) => this.setState(appState),+ x,+ y,+ pointerDownState.lastCoords.x,+ pointerDownState.lastCoords.y,+ );++ if (didDrag) {+ pointerDownState.lastCoords.x = x;+ pointerDownState.lastCoords.y = y;+ return;+ }+ }++ const hitElement = pointerDownState.hit.element;+ if (hitElement && this.state.selectedElementIds[hitElement.id]) {+ // Marking that click was used for dragging to check+ // if elements should be deselected on pointerup+ pointerDownState.drag.hasOccurred = true;+ const selectedElements = getSelectedElements(+ globalSceneState.getElements(),+ this.state,+ );+ if (selectedElements.length > 0) {+ const [dragX, dragY] = getGridPoint(+ x - pointerDownState.drag.offset.x,+ y - pointerDownState.drag.offset.y,+ this.state.gridSize,+ );+ dragSelectedElements(selectedElements, dragX, dragY);++ // We duplicate the selected element if alt is pressed on pointer move+ if (event.altKey && !pointerDownState.hit.hasBeenDuplicated) {+ // Move the currently selected elements to the top of the z index stack, and+ // put the duplicates where the selected elements used to be.+ // (the origin point where the dragging started)++ pointerDownState.hit.hasBeenDuplicated = true;++ const nextElements = [];+ const elementsToAppend = [];+ const groupIdMap = new Map();+ for (const element of globalSceneState.getElementsIncludingDeleted()) {+ if (+ this.state.selectedElementIds[element.id] ||+ // case: the state.selectedElementIds might not have been+ // updated yet by the time this mousemove event is fired+ (element.id === hitElement.id &&+ pointerDownState.hit.wasAddedToSelection)+ ) {+ const duplicatedElement = duplicateElement(+ this.state.editingGroupId,+ groupIdMap,+ element,+ );+ const [originDragX, originDragY] = getGridPoint(+ pointerDownState.origin.x - pointerDownState.drag.offset.x,+ pointerDownState.origin.y - pointerDownState.drag.offset.y,+ this.state.gridSize,+ );+ mutateElement(duplicatedElement, {+ x: duplicatedElement.x + (originDragX - dragX),+ y: duplicatedElement.y + (originDragY - dragY),+ });+ nextElements.push(duplicatedElement);+ elementsToAppend.push(element);+ } else {+ nextElements.push(element);+ }+ }+ globalSceneState.replaceAllElements([+ ...nextElements,+ ...elementsToAppend,+ ]);+ }+ return;+ }+ }++ // It is very important to read this.state within each move event,+ // otherwise we would read a stale one!+ const draggingElement = this.state.draggingElement;+ if (!draggingElement) {+ return;+ }- window.addEventListener(EVENT.POINTER_MOVE, onPointerMove);- window.addEventListener(EVENT.POINTER_UP, onPointerUp);- return true;- }+ if (isLinearElement(draggingElement)) {+ pointerDownState.drag.hasOccurred = true;+ const points = draggingElement.points;+ let dx: number;+ let dy: number;+ if (draggingElement.type === "draw") {+ dx = x - draggingElement.x;+ dy = y - draggingElement.y;+ } else {+ dx = gridX - draggingElement.x;+ dy = gridY - draggingElement.y;+ }- private clearSelectionIfNotUsingSelection = (): void => {- if (this.state.elementType !== "selection") {- this.setState({- selectedElementIds: {},- selectedGroupIds: {},- editingGroupId: null,- });- }- };+ if (getRotateWithDiscreteAngleKey(event) && points.length === 2) {+ ({ width: dx, height: dy } = getPerfectElementSize(+ this.state.elementType,+ dx,+ dy,+ ));+ }- // Returns whether the pointer event has been completely handled- private handleSelectionOnPointerDown = (- event: React.PointerEvent<HTMLCanvasElement>,- pointerDownState: PointerDownState,- ): boolean => {- if (this.state.elementType === "selection") {- const elements = globalSceneState.getElements();- const selectedElements = getSelectedElements(elements, this.state);- if (selectedElements.length === 1 && !this.state.editingLinearElement) {- const elementWithResizeHandler = getElementWithResizeHandler(- elements,- this.state,+ if (points.length === 1) {+ mutateElement(draggingElement, { points: [...points, [dx, dy]] });+ } else if (points.length > 1) {+ if (draggingElement.type === "draw") {+ mutateElement(draggingElement, {+ points: simplify([...(points as Point[]), [dx, dy]], 0.7),+ });+ } else {+ mutateElement(draggingElement, {+ points: [...points.slice(0, -1), [dx, dy]],+ });+ }+ }+ } else if (draggingElement.type === "selection") {+ dragNewElement(+ draggingElement,+ this.state.elementType,pointerDownState.origin.x,pointerDownState.origin.y,- this.state.zoom,- event.pointerType,+ x,+ y,+ distance(pointerDownState.origin.x, x),+ distance(pointerDownState.origin.y, y),+ getResizeWithSidesSameLengthKey(event),+ getResizeCenterPointKey(event),);- if (elementWithResizeHandler != null) {+ } else {+ dragNewElement(+ draggingElement,+ this.state.elementType,+ pointerDownState.originInGrid.x,+ pointerDownState.originInGrid.y,+ gridX,+ gridY,+ distance(pointerDownState.originInGrid.x, gridX),+ distance(pointerDownState.originInGrid.y, gridY),+ getResizeWithSidesSameLengthKey(event),+ getResizeCenterPointKey(event),+ );+ }++ if (this.state.elementType === "selection") {+ const elements = globalSceneState.getElements();+ if (!event.shiftKey && isSomeElementSelected(elements, this.state)) {this.setState({- resizingElement: elementWithResizeHandler.element,+ selectedElementIds: {},+ selectedGroupIds: {},+ editingGroupId: null,});- pointerDownState.resize.handle =- elementWithResizeHandler.resizeHandle;}- } else if (selectedElements.length > 1) {- pointerDownState.resize.handle = getResizeHandlerFromCoords(- getCommonBounds(selectedElements),- pointerDownState.origin.x,- pointerDownState.origin.y,- this.state.zoom,- event.pointerType,+ const elementsWithinSelection = getElementsWithinSelection(+ elements,+ draggingElement,);- }- if (pointerDownState.resize.handle) {- document.documentElement.style.cursor = getCursorForResizingElement({- resizeHandle: pointerDownState.resize.handle,- });- pointerDownState.resize.isResizing = true;- pointerDownState.resize.offset = tupleToCoors(- getResizeOffsetXY(- pointerDownState.resize.handle,- selectedElements,- pointerDownState.origin.x,- pointerDownState.origin.y,+ this.setState((prevState) =>+ selectGroupsForSelectedElements(+ {+ ...prevState,+ selectedElementIds: {+ ...prevState.selectedElementIds,+ ...elementsWithinSelection.reduce((map, element) => {+ map[element.id] = true;+ return map;+ }, {} as any),+ },+ },+ globalSceneState.getElements(),),);- if (- selectedElements.length === 1 &&- isLinearElement(selectedElements[0]) &&- selectedElements[0].points.length === 2- ) {- pointerDownState.resize.arrowDirection = getResizeArrowDirection(- pointerDownState.resize.handle,- selectedElements[0],- );- }- } else {- if (this.state.editingLinearElement) {- const ret = LinearElementEditor.handlePointerDown(- event,- this.state,- (appState) => this.setState(appState),- history,- pointerDownState.origin.x,- pointerDownState.origin.y,- );- if (ret.hitElement) {- pointerDownState.hit.element = ret.hitElement;- }- if (ret.didAddPoint) {- return true;- }- }+ }+ });+ }- // hitElement may already be set above, so check first- pointerDownState.hit.element =- pointerDownState.hit.element ??- getElementAtPosition(- elements,- this.state,- pointerDownState.origin.x,- pointerDownState.origin.y,- this.state.zoom,- );+ private onPointerUpFromPointerDownHandler(+ pointerDownState: PointerDownState,+ ): (event: PointerEvent) => void {+ return withBatchedUpdates((childEvent: PointerEvent) => {+ const {+ draggingElement,+ resizingElement,+ multiElement,+ elementType,+ elementLocked,+ } = this.state;- this.maybeClearSelectionWhenHittingElement(- event,- pointerDownState.hit.element,+ this.setState({+ isResizing: false,+ isRotating: false,+ resizingElement: null,+ selectionElement: null,+ cursorButton: "up",+ // text elements are reset on finalize, and resetting on pointerup+ // may cause issues with double taps+ editingElement:+ multiElement || isTextElement(this.state.editingElement)+ ? this.state.editingElement+ : null,+ });++ this.savePointer(childEvent.clientX, childEvent.clientY, "up");++ // if moving start/end point towards start/end point within threshold,+ // close the loop+ if (this.state.editingLinearElement) {+ const editingLinearElement = LinearElementEditor.handlePointerUp(+ this.state.editingLinearElement,);+ if (editingLinearElement !== this.state.editingLinearElement) {+ this.setState({ editingLinearElement });+ }+ }- // If we click on something- const hitElement = pointerDownState.hit.element;- if (hitElement != null) {- // deselect if item is selected- // if shift is not clicked, this will always return true- // otherwise, it will trigger selection based on current- // state of the box- if (!this.state.selectedElementIds[hitElement.id]) {- // if we are currently editing a group, treat all selections outside of the group- // as exiting editing mode.- if (- this.state.editingGroupId &&- !isElementInGroup(hitElement, this.state.editingGroupId)- ) {- this.setState({- selectedElementIds: {},- selectedGroupIds: {},- editingGroupId: null,- });- return true;- }- this.setState((prevState) => {- return selectGroupsForSelectedElements(- {- ...prevState,- selectedElementIds: {- ...prevState.selectedElementIds,- [hitElement!.id]: true,- },- },- globalSceneState.getElements(),- );- });- // TODO: this is strange...- globalSceneState.replaceAllElements(- globalSceneState.getElementsIncludingDeleted(),- );- pointerDownState.hit.wasAddedToSelection = true;+ lastPointerUp = null;++ window.removeEventListener(+ EVENT.POINTER_MOVE,+ pointerDownState.eventListeners.onMove!,+ );+ window.removeEventListener(+ EVENT.POINTER_UP,+ pointerDownState.eventListeners.onUp!,+ );++ if (draggingElement?.type === "draw") {+ this.actionManager.executeAction(actionFinalize);+ return;+ }+ if (isLinearElement(draggingElement)) {+ if (draggingElement!.points.length > 1) {+ history.resumeRecording();+ }+ if (+ !pointerDownState.drag.hasOccurred &&+ draggingElement &&+ !multiElement+ ) {+ const { x, y } = viewportCoordsToSceneCoords(+ childEvent,+ this.state,+ this.canvas,+ window.devicePixelRatio,+ );+ mutateElement(draggingElement, {+ points: [+ ...draggingElement.points,+ [x - draggingElement.x, y - draggingElement.y],+ ],+ });+ this.setState({+ multiElement: draggingElement,+ editingElement: this.state.draggingElement,+ });+ } else if (pointerDownState.drag.hasOccurred && !multiElement) {+ if (!elementLocked) {+ resetCursor();+ this.setState((prevState) => ({+ draggingElement: null,+ elementType: "selection",+ selectedElementIds: {+ ...prevState.selectedElementIds,+ [this.state.draggingElement!.id]: true,+ },+ }));+ } else {+ this.setState((prevState) => ({+ draggingElement: null,+ selectedElementIds: {+ ...prevState.selectedElementIds,+ [this.state.draggingElement!.id]: true,+ },+ }));}}+ return;+ }- const { selectedElementIds } = this.state;+ if (+ elementType !== "selection" &&+ draggingElement &&+ isInvisiblySmallElement(draggingElement)+ ) {+ // remove invisible element which was added in onPointerDown+ globalSceneState.replaceAllElements(+ globalSceneState.getElementsIncludingDeleted().slice(0, -1),+ );this.setState({- previousSelectedElementIds: selectedElementIds,+ draggingElement: null,});+ return;}- }- return false;- };- private handleTextOnPointerDown = (- event: React.PointerEvent<HTMLCanvasElement>,- pointerDownState: PointerDownState,- ): void => {- // if we're currently still editing text, clicking outside- // should only finalize it, not create another (irrespective- // of state.elementLocked)- if (this.state.editingElement?.type === "text") {- return;- }+ if (draggingElement) {+ mutateElement(+ draggingElement,+ getNormalizedDimensions(draggingElement),+ );+ }- this.startTextEditing({- sceneX: pointerDownState.origin.x,- sceneY: pointerDownState.origin.y,- insertAtParentCenter: !event.altKey,- });+ if (resizingElement) {+ history.resumeRecording();+ }- resetCursor();- if (!this.state.elementLocked) {- this.setState({- elementType: "selection",- });- }- };+ if (resizingElement && isInvisiblySmallElement(resizingElement)) {+ globalSceneState.replaceAllElements(+ globalSceneState+ .getElementsIncludingDeleted()+ .filter((el) => el.id !== resizingElement.id),+ );+ }- private handleLinearElementOnPointerDown = (- event: React.PointerEvent<HTMLCanvasElement>,- elementType: "draw" | "line" | "arrow",- pointerDownState: PointerDownState,- ): void => {- if (this.state.multiElement) {- const { multiElement } = this.state;+ // If click occurred on already selected element+ // it is needed to remove selection from other elements+ // or if SHIFT or META key pressed remove selection+ // from hitted element+ //+ // If click occurred and elements were dragged or some element+ // was added to selection (on pointerdown phase) we need to keep+ // selection unchanged+ const hitElement = pointerDownState.hit.element;+ if (+ getSelectedGroupIds(this.state).length === 0 &&+ hitElement &&+ !pointerDownState.drag.hasOccurred &&+ !pointerDownState.hit.wasAddedToSelection+ ) {+ if (childEvent.shiftKey) {+ this.setState((prevState) => ({+ selectedElementIds: {+ ...prevState.selectedElementIds,+ [hitElement!.id]: false,+ },+ }));+ } else {+ this.setState((_prevState) => ({+ selectedElementIds: { [hitElement!.id]: true },+ }));+ }+ }- // finalize if completing a loop- if (multiElement.type === "line" && isPathALoop(multiElement.points)) {- mutateElement(multiElement, {- lastCommittedPoint:- multiElement.points[multiElement.points.length - 1],+ if (draggingElement === null) {+ // if no element is clicked, clear the selection and redraw+ this.setState({+ selectedElementIds: {},+ selectedGroupIds: {},+ editingGroupId: null,});- this.actionManager.executeAction(actionFinalize);return;}- const { x: rx, y: ry, lastCommittedPoint } = multiElement;+ if (!elementLocked) {+ this.setState((prevState) => ({+ selectedElementIds: {+ ...prevState.selectedElementIds,+ [draggingElement.id]: true,+ },+ }));+ }- // clicking inside commit zone → finalize arrowif (- multiElement.points.length > 1 &&- lastCommittedPoint &&- distance2d(- pointerDownState.origin.x - rx,- pointerDownState.origin.y - ry,- lastCommittedPoint[0],- lastCommittedPoint[1],- ) < LINE_CONFIRM_THRESHOLD+ elementType !== "selection" ||+ isSomeElementSelected(globalSceneState.getElements(), this.state)) {- this.actionManager.executeAction(actionFinalize);- return;+ history.resumeRecording();}- this.setState((prevState) => ({- selectedElementIds: {- ...prevState.selectedElementIds,- [multiElement.id]: true,- },- }));- // clicking outside commit zone → update reference for last committed- // point- mutateElement(multiElement, {- lastCommittedPoint: multiElement.points[multiElement.points.length - 1],- });- document.documentElement.style.cursor = CURSOR_TYPE.POINTER;- } else {- const [gridX, gridY] = getGridPoint(- pointerDownState.origin.x,- pointerDownState.origin.y,- elementType === "draw" ? null : this.state.gridSize,- );- const element = newLinearElement({- type: elementType,- x: gridX,- y: gridY,- strokeColor: this.state.currentItemStrokeColor,- backgroundColor: this.state.currentItemBackgroundColor,- fillStyle: this.state.currentItemFillStyle,- strokeWidth: this.state.currentItemStrokeWidth,- strokeStyle: this.state.currentItemStrokeStyle,- roughness: this.state.currentItemRoughness,- opacity: this.state.currentItemOpacity,- });- this.setState((prevState) => ({- selectedElementIds: {- ...prevState.selectedElementIds,- [element.id]: false,- },- }));- mutateElement(element, {- points: [...element.points, [0, 0]],- });- globalSceneState.replaceAllElements([- ...globalSceneState.getElementsIncludingDeleted(),- element,- ]);- this.setState({- draggingElement: element,- editingElement: element,- });- }- };-- private createGenericElementOnPointerDown = (- elementType: ExcalidrawGenericElement["type"],- pointerDownState: PointerDownState,- ): void => {- const [gridX, gridY] = getGridPoint(- pointerDownState.origin.x,- pointerDownState.origin.y,- this.state.gridSize,- );- const element = newElement({- type: elementType,- x: gridX,- y: gridY,- strokeColor: this.state.currentItemStrokeColor,- backgroundColor: this.state.currentItemBackgroundColor,- fillStyle: this.state.currentItemFillStyle,- strokeWidth: this.state.currentItemStrokeWidth,- strokeStyle: this.state.currentItemStrokeStyle,- roughness: this.state.currentItemRoughness,- opacity: this.state.currentItemOpacity,+ if (!elementLocked) {+ resetCursor();+ this.setState({+ draggingElement: null,+ elementType: "selection",+ });+ } else {+ this.setState({+ draggingElement: null,+ });+ }});-- if (element.type === "selection") {- this.setState({- selectionElement: element,- draggingElement: element,- });- } else {- globalSceneState.replaceAllElements([- ...globalSceneState.getElementsIncludingDeleted(),- element,- ]);- this.setState({- multiElement: null,- draggingElement: element,- editingElement: element,- });- }- };+ }private maybeClearSelectionWhenHittingElement(event: React.PointerEvent<HTMLCanvasElement>,diff --git a/src/scene/scrollbars.ts b/src/scene/scrollbars.tsindex d6831257a6..af43b264ef 100644--- a/src/scene/scrollbars.ts+++ b/src/scene/scrollbars.ts@@ -107,10 +107,11 @@ export const isOverScrollBars = (x: number,y: number,): {- isOverHorizontalScrollBar: boolean;- isOverVerticalScrollBar: boolean;+ isOverEither: boolean;+ isOverHorizontal: boolean;+ isOverVertical: boolean;} => {- const [isOverHorizontalScrollBar, isOverVerticalScrollBar] = [+ const [isOverHorizontal, isOverVertical] = [scrollBars.horizontal,scrollBars.vertical,].map((scrollBar) => {@@ -122,9 +123,6 @@ export const isOverScrollBars = (y <= scrollBar.y + scrollBar.height);});-- return {- isOverHorizontalScrollBar,- isOverVerticalScrollBar,- };+ const isOverEither = isOverHorizontal || isOverVertical;+ return { isOverEither, isOverHorizontal, isOverVertical };};