marcel/excalidraw
1
0
Fork 0
mirror of https://github.com/excalidraw/excalidraw.git synced 2025-11-19 12:14:24 +01:00
Code Issues Packages Projects Releases Wiki Activity

Revert "fix: Arrow angle"

Browse Source 
This reverts commit 7f0aa5854a.
This commit is contained in:
Mark Tolmacs
2025-11-17 19:20:18 +01:00
parent 7f0aa5854a
commit d46c38cb27
3 changed files with 63 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
packages/element/src/linearElementEditor.ts
View File

@@ -2243,36 +2243,44 @@ const pointDraggingUpdates = (
}
// Simulate the updated arrow for the bind point calculation
const updatedPoints = element.points.map((p, idx) => {
const update = naiveDraggingPoints.get(idx);
return update ? update.point : p;
});
const offsetX = updatedPoints[0][0];
const offsetY = updatedPoints[0][1];
const normalizedPoints = updatedPoints.map((p) =>
pointFrom<LocalPoint>(p[0] - offsetX, p[1] - offsetY),
);
const nextCoords = getElementPointsCoords(element, normalizedPoints);
const prevCoords = getElementPointsCoords(element, element.points);
const nextCenterX = (nextCoords[0] + nextCoords[2]) / 2;
const nextCenterY = (nextCoords[1] + nextCoords[3]) / 2;
const prevCenterX = (prevCoords[0] + prevCoords[2]) / 2;
const prevCenterY = (prevCoords[1] + prevCoords[3]) / 2;
const dX = prevCenterX - nextCenterX;
const dY = prevCenterY - nextCenterY;
const rotatedOffset = pointRotateRads(
pointFrom(offsetX, offsetY),
pointFrom(dX, dY),
element.angle,
const originalStartGlobalPoint =
LinearElementEditor.getPointAtIndexGlobalCoordinates(
element,
0,
elementsMap,
);
const offsetStartGlobalPoint = startIsDragged
? pointFrom<GlobalPoint>(
originalStartGlobalPoint[0] + deltaX,
originalStartGlobalPoint[1] + deltaY,
)
: originalStartGlobalPoint;
const offsetStartLocalPoint = LinearElementEditor.pointFromAbsoluteCoords(
element,
offsetStartGlobalPoint,
elementsMap,
);
const offsetEndLocalPoint = endIsDragged
? pointFrom<LocalPoint>(
element.points[element.points.length - 1][0] + deltaX,
element.points[element.points.length - 1][1] + deltaY,
)
: element.points[element.points.length - 1];
const nextArrow = {
...element,
points: normalizedPoints,
x: element.x + rotatedOffset[0],
y: element.y + rotatedOffset[1],
points: [
offsetStartLocalPoint,
...element.points
.slice(1, -1)
.map((p) =>
pointFrom<LocalPoint>(
p[0] + element.x - offsetStartGlobalPoint[0],
p[1] + element.y - offsetStartGlobalPoint[1],
),
),
offsetEndLocalPoint,
],
startBinding:
updates.startBinding === undefined
? element.startBinding
@@ -2365,16 +2373,6 @@ const pointDraggingUpdates = (
) || nextArrow.points[0]
: nextArrow.points[0];
const startOffset = pointFrom<LocalPoint>(offsetX, offsetY);
const startLocalPointAbsolute = pointFrom<LocalPoint>(
startLocalPoint[0] + startOffset[0],
startLocalPoint[1] + startOffset[1],
);
const endLocalPointAbsolute = pointFrom<LocalPoint>(
endLocalPoint[0] + startOffset[0],
endLocalPoint[1] + startOffset[1],
);
const endChanged =
pointDistance(
endLocalPoint,
@@ -2405,9 +2403,9 @@ const pointDraggingUpdates = (
return [
idx,
idx === 0
? { point: startLocalPointAbsolute, isDragging: true }
? { point: startLocalPoint, isDragging: true }
: idx === element.points.length - 1
? { point: endLocalPointAbsolute, isDragging: true }
? { point: endLocalPoint, isDragging: true }
: naiveDraggingPoints.get(idx)!,
];
}),