Skip to content

The free and privacy-friendly screen recorder with no limits 🎥

Fix drawing tools + editor resilience

Alyssa Xac2b9551caa3
diff --git a/src/manifest.json b/src/manifest.json
index af826f6..7f9ae61 100755
--- a/src/manifest.json
+++ b/src/manifest.json
@@ -3,7 +3,7 @@
"name": "__MSG_extName__",
"description": "__MSG_extDesc__",
"default_locale": "en",
- "version": "4.2.4",
+ "version": "4.2.5",
"background": {
"service_worker": "background.bundle.js"
},
diff --git a/src/pages/CloudRecorder/bunnyTusUploader.js b/src/pages/CloudRecorder/bunnyTusUploader.js
index 6286a10..912c403 100644
--- a/src/pages/CloudRecorder/bunnyTusUploader.js
+++ b/src/pages/CloudRecorder/bunnyTusUploader.js
@@ -67,6 +67,7 @@ export default class BunnyTusUploader {
this.onProgress = options.onProgress || null;
this.onStall = options.onStall || null;
+ this.totalBytes = 0;
this.uploadUrl = null;
this.offset = 0;
this.projectId = null;
@@ -119,6 +120,7 @@ export default class BunnyTusUploader {
this.status = "initializing";
this.error = null;
this.offset = 0;
+ this.totalBytes = 0;
// Validate reuse object if provided
if (reuse) {
@@ -244,6 +246,7 @@ export default class BunnyTusUploader {
const subChunk = chunk.slice(i, i + this.CHUNK_SIZE);
this.chunkQueue.push(subChunk);
this.queuedBytes += subChunk.size;
+ this.totalBytes += subChunk.size;
}
// Always ensure queue is processing
@@ -279,7 +282,6 @@ export default class BunnyTusUploader {
for (let attempt = 0; attempt <= this.MAX_RETRIES; attempt++) {
try {
const currentOffset = this.offset;
- this.offset += data.length;
const controller = new AbortController();
const timeout = setTimeout(
@@ -304,22 +306,13 @@ export default class BunnyTusUploader {
clearTimeout(timeout);
if (res.ok || res.status === 204) {
- // Verify server offset matches our expectation
- const serverOffset = res.headers.get("Upload-Offset");
- const expectedOffset = currentOffset + data.length;
-
- if (serverOffset) {
- const actualOffset = parseInt(serverOffset);
- if (actualOffset !== expectedOffset) {
- console.warn(
- `⚠️ Offset mismatch! Expected: ${expectedOffset}, Server: ${actualOffset}`
- );
- this.offset = actualOffset;
- } else {
- this.offset = expectedOffset;
- }
+ // Server is the source of truth
+ const serverOffsetHeader = res.headers.get("Upload-Offset");
+ if (serverOffsetHeader) {
+ this.offset = parseInt(serverOffsetHeader, 10);
} else {
- this.offset = expectedOffset;
+ // Fallback if Bunny doesn't return it for some reason
+ this.offset = currentOffset + data.length;
}
this.recordProgress(data.length);
@@ -484,16 +477,8 @@ export default class BunnyTusUploader {
await this.waitForPendingUploads();
await this.checkAuthExpiration();
- // Validate that we actually uploaded data
- if (this.offset === 0) {
- this.status = "error";
- this.error = "No data uploaded - offset is 0";
- throw new Error(
- "Cannot finalize upload with zero bytes. No chunks were successfully uploaded."
- );
- }
-
// Re-validate offset with server to avoid partial finalization
+ let serverOffset = null;
try {
const headRes = await fetch(this.uploadUrl, {
method: "HEAD",
@@ -507,27 +492,51 @@ export default class BunnyTusUploader {
});
if (headRes.ok) {
- const serverOffset = parseInt(
- headRes.headers.get("Upload-Offset") || "0"
+ serverOffset = parseInt(
+ headRes.headers.get("Upload-Offset") || "0",
+ 10
);
- if (serverOffset !== this.offset) {
- console.warn(
- `⚠️ Finalize correcting offset from ${this.offset} to ${serverOffset}`
- );
- this.offset = serverOffset;
- }
+ this.offset = serverOffset;
}
} catch (err) {
- console.warn("⚠️ Failed to verify offset before finalize:", err);
+ console.warn("⚠️ Failed HEAD before finalize:", err);
+ }
+
+ // If server didn't receive everything, don't "finalize" into a ghost upload.
+ if (serverOffset === null) {
+ throw new Error("Finalize failed: could not verify server offset.");
+ }
+
+ if (serverOffset === 0) {
+ this.status = "error";
+ this.error = "server-offset-0";
+ throw new Error("Finalize failed: server has 0 bytes.");
+ }
+
+ if (serverOffset < this.totalBytes) {
+ this.status = "error";
+ this.error = `incomplete-upload server=${serverOffset} expected=${this.totalBytes}`;
+ throw new Error(
+ `Finalize blocked: upload incomplete (server ${serverOffset} / expected ${this.totalBytes}).`
+ );
+ }
+
+ if (serverOffset > this.totalBytes) {
+ this.status = "error";
+ this.error = `invalid-length server=${serverOffset} expected=${this.totalBytes}`;
+ throw new Error(
+ `Finalize blocked: serverOffset (${serverOffset}) exceeds expected totalBytes (${this.totalBytes}).`
+ );
}
+ // Now we can safely complete the tus upload by declaring the final length
const res = await fetch(this.uploadUrl, {
method: "PATCH",
headers: {
"Tus-Resumable": "1.0.0",
"Content-Type": "application/offset+octet-stream",
- "Upload-Offset": String(this.offset),
- "Upload-Length": String(this.offset),
+ "Upload-Offset": String(serverOffset),
+ "Upload-Length": String(this.totalBytes),
AuthorizationSignature: this.signature,
AuthorizationExpire: String(this.expires),
LibraryId: String(this.libraryId),
@@ -581,6 +590,7 @@ export default class BunnyTusUploader {
this.uploadUrl = null;
this.chunkQueue = [];
this.queuedBytes = 0;
+ this.totalBytes = 0;
this.pendingUploads = [];
this.stopHeartbeat();
}
diff --git a/src/pages/Content/canvas/layout/CanvasWrap.jsx b/src/pages/Content/canvas/layout/CanvasWrap.jsx
index 49efa66..a20dfe4 100644
--- a/src/pages/Content/canvas/layout/CanvasWrap.jsx
+++ b/src/pages/Content/canvas/layout/CanvasWrap.jsx
@@ -63,7 +63,7 @@ const CanvasWrap = (props) => {
...contentState,
canvas: canvas,
},
- setContentState
+ setContentState,
);
}, []);
@@ -83,6 +83,39 @@ const CanvasWrap = (props) => {
};
}, []);
+ useEffect(() => {
+ const canvas = fabricRef.current;
+ if (!canvas) return;
+
+ const tool = contentState.tool;
+
+ const shouldDraw =
+ contentState.drawingMode && (tool === "pen" || tool === "highlighter");
+
+ canvas.isDrawingMode = shouldDraw;
+
+ // Important: when leaving pen/highlighter, clear any in-progress brush stroke
+ if (!shouldDraw && canvas.freeDrawingBrush) {
+ const brush = canvas.freeDrawingBrush;
+ if (Array.isArray(brush._points)) brush._points.length = 0;
+ if (Array.isArray(brush.points)) brush.points.length = 0;
+ if (typeof brush._reset === "function") brush._reset();
+ }
+
+ canvas.requestRenderAll();
+ }, [contentState.tool, contentState.drawingMode]);
+
+ useEffect(() => {
+ const canvas = fabricRef.current;
+ if (!canvas) return;
+
+ // Only discard selection when leaving select (or when entering a drawing tool)
+ if (contentState.tool !== "select") {
+ canvas.discardActiveObject();
+ canvas.requestRenderAll();
+ }
+ }, [contentState.tool]);
+
const panXRef = useRef(window.scrollX);
const panYRef = useRef(window.scrollY);
@@ -128,36 +161,33 @@ const CanvasWrap = (props) => {
useEffect(() => {
if (!fabricRef.current) return;
- const eraserDrawing = EraserTool(
- fabricRef.current,
- contentState,
- setContentState
- );
+ const canvas = fabricRef.current;
+ // Pass a ref getter instead of snapshot state
const arrowDrawing = ArrowTool(
- fabricRef.current,
- contentState,
+ canvas,
+ contentStateRef,
setContentState,
- saveCanvas
+ saveCanvas,
);
-
+ const eraserDrawing = EraserTool(canvas, contentStateRef, setContentState);
const shapeDrawing = ShapeTool(
- fabricRef.current,
- contentState,
+ canvas,
+ contentStateRef,
setContentState,
- saveCanvas
+ saveCanvas,
);
const textDrawing = TextTool(
- fabricRef.current,
- contentState,
+ canvas,
+ contentStateRef,
setContentState,
- saveCanvas
+ saveCanvas,
);
const penDrawing = PenTool(
- fabricRef.current,
- contentState,
+ canvas,
+ contentStateRef,
setContentState,
- saveCanvas
+ saveCanvas,
);
return () => {
@@ -167,25 +197,25 @@ const CanvasWrap = (props) => {
textDrawing.removeEventListeners();
penDrawing.removeEventListeners();
};
- }, [contentState]);
+ }, []);
useEffect(() => {
- const selection = SelectTool(
- fabricRef.current,
- contentState,
- setContentState
- );
+ if (!fabricRef.current) return;
+
+ const canvas = fabricRef.current;
+
+ const selection = SelectTool(canvas, contentStateRef, setContentState);
const objectChanges = checkChanges(
- fabricRef.current,
- contentState,
- setContentState
+ canvas,
+ contentStateRef,
+ setContentState,
);
return () => {
selection.removeEventListeners();
objectChanges.removeEventListeners();
};
- }, [fabricRef, contentState]);
+ }, []);
useEffect(() => {
// Prevent selecting elements unless in select mode
@@ -208,24 +238,30 @@ const CanvasWrap = (props) => {
}
}, [contentState.tool]);
- // handle what happens on key press
- const handleKeyPress = (event) => {
- if ((event.ctrlKey || event.metaKey) && event.key === "z")
- undoCanvas(contentState, setContentState);
- if ((event.ctrlKey || event.metaKey) && event.shiftKey && event.key === "z")
- redoCanvas(contentState, setContentState);
- };
-
useEffect(() => {
- if (!fabricRef.current) return;
- // attach the event listener
- document.addEventListener("keydown", handleKeyPress);
-
- // remove the event listener
- return () => {
- document.removeEventListener("keydown", handleKeyPress);
+ const onKeyDown = (event) => {
+ const state = contentStateRef.current;
+ if (!state) return;
+
+ if (
+ (event.ctrlKey || event.metaKey) &&
+ event.key.toLowerCase() === "z" &&
+ !event.shiftKey
+ ) {
+ undoCanvas(state, setContentState);
+ }
+ if (
+ (event.ctrlKey || event.metaKey) &&
+ (event.key.toLowerCase() === "y" ||
+ (event.shiftKey && event.key.toLowerCase() === "z"))
+ ) {
+ redoCanvas(state, setContentState);
+ }
};
- }, [handleKeyPress, fabricRef.current, contentState]);
+
+ document.addEventListener("keydown", onKeyDown);
+ return () => document.removeEventListener("keydown", onKeyDown);
+ }, []);
useEffect(() => {
if (!fabricRef.current) return;
diff --git a/src/pages/Content/canvas/modules/ArrowTool.jsx b/src/pages/Content/canvas/modules/ArrowTool.jsx
index 5c74eac..922a973 100644
--- a/src/pages/Content/canvas/modules/ArrowTool.jsx
+++ b/src/pages/Content/canvas/modules/ArrowTool.jsx
@@ -1,21 +1,23 @@
import { fabric } from "fabric";
-const createArrowLine = (x, y, color, toolSettings) => {
+const createArrowLine = (x, y, color, strokeWidth) => {
return new fabric.Line([x, y, x, y], {
- strokeWidth: toolSettings.strokeWidth * 6,
+ strokeWidth: (strokeWidth || 2) * 6,
stroke: color,
originX: "center",
originY: "center",
selectable: false,
evented: false,
id: "arrowLine",
+ objectCaching: false,
});
};
-const createArrowHead = (x, y, color, toolSettings) => {
+const createArrowHead = (x, y, color, strokeWidth) => {
+ const size = (strokeWidth || 2) * 16;
return new fabric.Triangle({
- width: toolSettings.strokeWidth * 16,
- height: toolSettings.strokeWidth * 16,
+ width: size,
+ height: size,
left: x,
top: y,
fill: color,
@@ -24,6 +26,7 @@ const createArrowHead = (x, y, color, toolSettings) => {
selectable: false,
evented: false,
id: "arrowHead",
+ objectCaching: false,
});
};
@@ -37,8 +40,9 @@ const createArrowCircle = (x, y, id) => {
top: y,
selectable: false,
evented: true,
- id: id,
+ id,
opacity: 0,
+ objectCaching: false,
});
};
@@ -52,147 +56,176 @@ const createArrowLineControl = (x, y) => {
evented: false,
id: "arrowLineControl",
opacity: 0,
+ objectCaching: false,
});
};
-const moveArrowCircle = (
- canvas,
- arrowCircle,
- saveCanvas,
- toolSettings,
- setToolSettings
-) => {
- let isDown = true;
- const group = arrowCircle.group;
- const items = group._objects;
-
- const arrowCircle1 = group._objects.find(
- (item) => item.id === "arrowCircle1"
- );
- const arrowCircle2 = group._objects.find(
- (item) => item.id === "arrowCircle2"
- );
- const arrowLine = group._objects.find((item) => item.id === "arrowLine");
- const arrowHead = group._objects.find((item) => item.id === "arrowHead");
- const arrowLineControl = group._objects.find(
- (item) => item.id === "arrowLineControl"
- );
- arrowLineControl.set({ opacity: 0 });
- group._restoreObjectsState();
-
- canvas.remove(group);
- items.forEach((item) => {
- canvas.add(item);
- });
- canvas.renderAll();
-
- canvas.on("mouse:move", (o) => {
- if (!isDown) return;
+const ArrowTool = (canvas, contentStateRef, setContentState, saveCanvas) => {
+ const getState = () => contentStateRef.current;
- const pointer = canvas.getPointer(o.e);
- const { x, y } = pointer;
- arrowCircle.set({ left: x - 5, top: y - 5 });
- canvas.renderAll();
-
- arrowLine.set({
- x1: arrowCircle1.left + 5,
- y1: arrowCircle1.top + 5,
- x2: arrowCircle2.left + 5,
- y2: arrowCircle2.top + 5,
- });
+ let arrowPoints = [];
+ let arrowLine = null;
+ let arrowHead = null;
+ let arrowCircle1 = null;
+ let arrowCircle2 = null;
+ let arrowLineControl = null;
- arrowLineControl.set({
- x1: arrowCircle1.left + 5,
- y1: arrowCircle1.top + 5,
- x2: arrowCircle2.left + 5,
- y2: arrowCircle2.top + 5,
- });
+ // --- endpoint drag handler (store ref so we can remove safely)
+ const onEndpointMouseDown = (e) => {
+ // Only when selecting / interacting with existing arrows
+ if (!e?.subTargets?.length) return;
- const xDiff = arrowLine.x2 - arrowLine.x1;
- const yDiff = arrowLine.y2 - arrowLine.y1;
- const angle = (Math.atan2(yDiff, xDiff) * 180) / Math.PI;
- arrowHead.set({ angle: angle + 90, left: arrowLine.x2, top: arrowLine.y2 });
- });
+ const state = getState();
+ // Allow endpoint dragging even if tool != arrow, but only in drawingMode
+ if (!state?.drawingMode) return;
- canvas.on("mouse:up", (o) => {
- if (!isDown) return;
- isDown = false;
- canvas.off("mouse:move");
- arrowLineControl.set({ opacity: 1 });
- const group = new fabric.Group(
- [arrowLine, arrowHead, arrowLineControl, arrowCircle1, arrowCircle2],
- {
- selectable: true,
- evented: true,
- id: "arrowGroup",
- hasControls: false,
- hasBorders: false,
- hasRotatingPoint: false,
- subTargetCheck: true,
- originX: "left",
- originY: "top",
- perPixelTargetFind: true,
- }
+ const hit = e.subTargets.find(
+ (obj) => obj?.id === "arrowCircle1" || obj?.id === "arrowCircle2",
);
+ if (!hit) return;
- canvas.add(group);
- canvas.remove(arrowLine);
- canvas.remove(arrowHead);
- canvas.remove(arrowCircle1);
- canvas.remove(arrowCircle2);
- canvas.remove(arrowLineControl);
- canvas.renderAll();
- canvas.setActiveObject(group);
- canvas.renderAll();
+ moveArrowCircle(canvas, hit, getState, saveCanvas, setContentState);
+ };
- // De-select arrow group
- canvas.discardActiveObject();
- canvas.renderAll();
- saveCanvas({ ...toolSettings, tool: "select" }, setToolSettings);
+ const moveArrowCircle = (
+ canvas,
+ arrowCircle,
+ getState,
+ saveCanvas,
+ setContentState,
+ ) => {
+ let isDown = true;
- // Re-select
- canvas.setActiveObject(group);
- canvas.renderAll();
- });
-};
+ const group = arrowCircle.group;
+ const items = group._objects;
-const ArrowTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
- let arrowPoints = [];
- let arrowLine = null;
- let arrowHead = null;
- let arrowCircle1 = null;
- let arrowCircle2 = null;
- let arrowLineControl = null;
+ const arrowCircle1 = group._objects.find(
+ (item) => item.id === "arrowCircle1",
+ );
+ const arrowCircle2 = group._objects.find(
+ (item) => item.id === "arrowCircle2",
+ );
+ const arrowLine = group._objects.find((item) => item.id === "arrowLine");
+ const arrowHead = group._objects.find((item) => item.id === "arrowHead");
+ const arrowLineControl = group._objects.find(
+ (item) => item.id === "arrowLineControl",
+ );
+
+ arrowLineControl.set({ opacity: 0 });
+
+ // Ungroup temporarily so we can edit in canvas coords
+ group._restoreObjectsState();
+ canvas.remove(group);
+ items.forEach((item) => canvas.add(item));
+ canvas.requestRenderAll();
+
+ const updateGeometry = () => {
+ const x1 = arrowCircle1.left + 5;
+ const y1 = arrowCircle1.top + 5;
+ const x2 = arrowCircle2.left + 5;
+ const y2 = arrowCircle2.top + 5;
+
+ arrowLine.set({ x1, y1, x2, y2 });
+ arrowLineControl.set({ x1, y1, x2, y2 });
+
+ arrowLine.setCoords();
+ arrowLineControl.setCoords();
+
+ const angle = (Math.atan2(y2 - y1, x2 - x1) * 180) / Math.PI;
+ arrowHead.set({ angle: angle + 90, left: x2, top: y2 });
+ arrowHead.setCoords();
+ };
+
+ const onMove = (o) => {
+ if (!isDown) return;
+
+ const pointer = canvas.getPointer(o.e);
+ arrowCircle.set({ left: pointer.x - 5, top: pointer.y - 5 });
+ arrowCircle.setCoords();
+
+ updateGeometry();
+ canvas.requestRenderAll();
+ };
+
+ const onUp = () => {
+ if (!isDown) return;
+ isDown = false;
+
+ canvas.off("mouse:move", onMove);
+ canvas.off("mouse:up", onUp);
+
+ arrowLineControl.set({ opacity: 1 });
+
+ const newGroup = new fabric.Group(
+ [arrowLine, arrowHead, arrowLineControl, arrowCircle1, arrowCircle2],
+ {
+ selectable: true,
+ evented: true,
+ id: "arrowGroup",
+ hasControls: false,
+ hasBorders: false,
+ hasRotatingPoint: false,
+ subTargetCheck: true,
+ originX: "left",
+ originY: "top",
+ perPixelTargetFind: true,
+ },
+ );
+
+ canvas.add(newGroup);
+ canvas.remove(arrowLine);
+ canvas.remove(arrowHead);
+ canvas.remove(arrowCircle1);
+ canvas.remove(arrowCircle2);
+ canvas.remove(arrowLineControl);
+ canvas.requestRenderAll();
+
+ canvas.discardActiveObject();
+ canvas.requestRenderAll();
+
+ const state = getState();
+ saveCanvas({ ...state, tool: "select" }, setContentState);
+
+ canvas.setActiveObject(newGroup);
+ canvas.requestRenderAll();
+ };
+
+ canvas.on("mouse:move", onMove);
+ canvas.on("mouse:up", onUp);
+ };
+ // --- draw handlers
const onMouseDown = (o) => {
- if (toolSettings.tool !== "arrow") return;
+ const state = getState();
+ if (!state?.drawingMode) return;
+ if (state.tool !== "arrow") return;
if (arrowPoints.length) return;
- // Disable canvas selection
canvas.selection = false;
- canvas.renderAll();
+ canvas.requestRenderAll();
- const pointer = canvas.getPointer(o.e);
- const x = pointer.x;
- const y = pointer.y;
+ const { x, y } = canvas.getPointer(o.e);
+ arrowPoints = [{ x, y }];
- arrowPoints.push({ x: x, y: y });
-
- arrowLine = createArrowLine(x, y, toolSettings.color, toolSettings);
- arrowHead = createArrowHead(x, y, toolSettings.color, toolSettings);
- arrowCircle1 = createArrowCircle(x, y, "arrowCircle1");
- arrowCircle2 = createArrowCircle(x, y, "arrowCircle2");
- arrowLineControl = createArrowLineControl(x, y, "arrowLineControl");
+ arrowLine = createArrowLine(x, y, state.color, state.strokeWidth);
+ arrowHead = createArrowHead(x, y, state.color, state.strokeWidth);
+ arrowCircle1 = createArrowCircle(x - 5, y - 5, "arrowCircle1");
+ arrowCircle2 = createArrowCircle(x - 5, y - 5, "arrowCircle2");
+ arrowLineControl = createArrowLineControl(x, y);
canvas.add(arrowLine);
canvas.add(arrowHead);
canvas.add(arrowLineControl);
canvas.add(arrowCircle1);
canvas.add(arrowCircle2);
+
+ canvas.requestRenderAll();
};
const onMouseMove = (o) => {
- if (toolSettings.tool !== "arrow") return;
+ const state = getState();
+ if (!state?.drawingMode) return;
+ if (state.tool !== "arrow") return;
if (!arrowPoints.length) return;
if (
!arrowLine ||
@@ -203,40 +236,37 @@ const ArrowTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
)
return;
- const pointer = canvas.getPointer(o.e);
- const x = pointer.x;
- const y = pointer.y;
+ const { x, y } = canvas.getPointer(o.e);
+ const startX = arrowPoints[0].x;
+ const startY = arrowPoints[0].y;
- arrowLine.set({ x2: x, y2: y });
- arrowLineControl.set({ x2: x, y2: y });
+ arrowLine.set({ x1: startX, y1: startY, x2: x, y2: y });
+ arrowLineControl.set({ x1: startX, y1: startY, x2: x, y2: y });
+ arrowLine.setCoords();
+ arrowLineControl.setCoords();
- arrowHead.set({ left: x, top: y });
+ const angle = (Math.atan2(y - startY, x - startX) * 180) / Math.PI;
+ arrowHead.set({ left: x, top: y, angle: angle + 90 });
+ arrowHead.setCoords();
- const xDiff = arrowLine.x2 - arrowLine.x1;
- const yDiff = arrowLine.y2 - arrowLine.y1;
- const angle = (Math.atan2(yDiff, xDiff) * 180) / Math.PI;
- arrowHead.set({ angle: angle + 90 });
+ arrowCircle1.set({ left: startX - 5, top: startY - 5 });
- // Position circle with offset to arrow head
- const xDiff2 = Math.cos(angle * (Math.PI / 180));
- const yDiff2 = Math.sin(angle * (Math.PI / 180));
- arrowCircle1.set({ left: arrowLine.x1 - 5, top: arrowLine.y1 - 5 });
- arrowCircle2.set({
- left: arrowLine.x2 + xDiff2 - 5,
- top: arrowLine.y2 + yDiff2 - 5,
- });
+ // keep your “slight offset” if you want, but simplest is:
+ arrowCircle2.set({ left: x - 5, top: y - 5 });
- canvas.renderAll();
+ arrowCircle1.setCoords();
+ arrowCircle2.setCoords();
+
+ canvas.requestRenderAll();
};
- const onMouseUp = (o) => {
- if (toolSettings.tool !== "arrow") return;
+ const onMouseUp = () => {
+ const state = getState();
+ if (!state?.drawingMode) return;
+ if (state.tool !== "arrow") return;
if (!arrowPoints.length) return;
- // Enable canvas selection
canvas.selection = true;
- canvas.renderAll();
-
arrowPoints = [];
arrowCircle1.set({ opacity: 1 });
@@ -256,7 +286,7 @@ const ArrowTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
originX: "left",
originY: "top",
perPixelTargetFind: true,
- }
+ },
);
canvas.add(group);
@@ -265,44 +295,16 @@ const ArrowTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
canvas.remove(arrowCircle1);
canvas.remove(arrowCircle2);
canvas.remove(arrowLineControl);
- canvas.renderAll();
- saveCanvas({ ...toolSettings, tool: "select" }, setToolSettings);
- canvas.setActiveObject(group);
- canvas.renderAll();
- };
- fabric.Canvas.prototype.getItem = function (id) {
- let object = null;
- const objects = this.getObjects();
+ canvas.requestRenderAll();
- for (let i = 0, len = this.size(); i < len; i++) {
- if (objects[i].id && objects[i].id === id) {
- object = objects[i];
- break;
- }
- }
-
- return object;
+ saveCanvas({ ...state, tool: "select" }, setContentState);
+ canvas.setActiveObject(group);
+ canvas.requestRenderAll();
};
- canvas.on("mouse:down", function (e) {
- // Check event subtargets if includes element with ID property arrowCircle1 or arrowCircle2
- if (e.subTargets) {
- e.subTargets.forEach((obj) => {
- if (obj.id === "arrowCircle1" || obj.id === "arrowCircle2") {
- moveArrowCircle(
- canvas,
- obj,
- saveCanvas,
- toolSettings,
- setToolSettings
- );
- }
- });
- }
- });
-
- canvas.on("before:selection:cleared", function (e) {
+ // --- selection visibility handlers (keep refs for proper off)
+ const onBeforeSelectionCleared = () => {
const activeObject = canvas.getActiveObject();
if (activeObject && activeObject.id === "arrowGroup") {
activeObject._objects.forEach((obj) => {
@@ -314,31 +316,13 @@ const ArrowTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
obj.set({ opacity: 0 });
}
});
- canvas.renderAll();
+ canvas.requestRenderAll();
}
- });
-
- canvas.on("selection:updated", function (e) {
- // Set opacity 0 to all arrow circles in the canvas (irrespective of group)
- canvas.getObjects().forEach((obj) => {
- if (obj.type == "group") {
- obj._objects.forEach((obj2) => {
- if (
- obj2.id === "arrowCircle1" ||
- obj2.id === "arrowCircle2" ||
- obj2.id === "arrowLineControl"
- ) {
- obj2.set({ opacity: 0 });
- }
- });
- }
- });
- });
+ };
- canvas.on("selection:cleared", function (e) {
- // Set opacity 0 to all arrow circles in the canvas (irrespective of group)
+ const onSelectionCleared = () => {
canvas.getObjects().forEach((obj) => {
- if (obj.type == "group") {
+ if (obj.type === "group") {
obj._objects.forEach((obj2) => {
if (
obj2.id === "arrowCircle1" ||
@@ -350,10 +334,12 @@ const ArrowTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
});
}
});
- });
+ canvas.requestRenderAll();
+ };
- canvas.on("selection:created", function (e) {
+ const onSelectionChanged = () => {
const activeObject = canvas.getActiveObject();
+
if (activeObject && activeObject.id === "arrowGroup") {
activeObject._objects.forEach((obj) => {
if (
@@ -364,52 +350,43 @@ const ArrowTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
obj.set({ opacity: 1 });
}
});
- canvas.renderAll();
+ canvas.requestRenderAll();
}
- // Also for multiple selection
if (activeObject && activeObject.type === "activeSelection") {
activeObject._objects.forEach((obj) => {
if (obj.id === "arrowGroup") {
obj._objects.forEach((obj2) => {
- if (obj2.id === "arrowLineControl") {
- obj2.set({ opacity: 1 });
- }
+ if (obj2.id === "arrowLineControl") obj2.set({ opacity: 1 });
});
}
});
- canvas.renderAll();
+ canvas.requestRenderAll();
}
- });
-
- canvas.on("selection:updated", function (e) {
- const activeObject = canvas.getActiveObject();
- if (activeObject && activeObject.id === "arrowGroup") {
- activeObject._objects.forEach((obj) => {
- if (
- obj.id === "arrowCircle1" ||
- obj.id === "arrowCircle2" ||
- obj.id === "arrowLineControl"
- ) {
- obj.set({ opacity: 1 });
- }
- });
- canvas.renderAll();
- }
- });
+ };
+ // attach
+ canvas.on("mouse:down", onEndpointMouseDown); // endpoint dragging
canvas.on("mouse:down", onMouseDown);
canvas.on("mouse:move", onMouseMove);
canvas.on("mouse:up", onMouseUp);
+ canvas.on("before:selection:cleared", onBeforeSelectionCleared);
+ canvas.on("selection:cleared", onSelectionCleared);
+ canvas.on("selection:created", onSelectionChanged);
+ canvas.on("selection:updated", onSelectionChanged);
+
return {
removeEventListeners: function () {
+ canvas.off("mouse:down", onEndpointMouseDown);
canvas.off("mouse:down", onMouseDown);
canvas.off("mouse:move", onMouseMove);
canvas.off("mouse:up", onMouseUp);
- canvas.off("before:selection:cleared");
- canvas.off("selection:cleared");
- canvas.off("mouse:down");
+
+ canvas.off("before:selection:cleared", onBeforeSelectionCleared);
+ canvas.off("selection:cleared", onSelectionCleared);
+ canvas.off("selection:created", onSelectionChanged);
+ canvas.off("selection:updated", onSelectionChanged);
},
};
};
diff --git a/src/pages/Content/canvas/modules/EraserTool.jsx b/src/pages/Content/canvas/modules/EraserTool.jsx
index b5fd967..fd6f435 100644
--- a/src/pages/Content/canvas/modules/EraserTool.jsx
+++ b/src/pages/Content/canvas/modules/EraserTool.jsx
@@ -1,134 +1,130 @@
-import React from "react";
-
-import { fabric } from "fabric";
import { saveCanvas } from "./History";
-const EraserTool = (canvas, toolSettings, setToolSettings) => {
- const tool = toolSettings;
-
- const removeEventListeners = () => {
- canvas.off("mouse:down");
- canvas.off("mouse:move");
- canvas.off("mouse:up");
- document.removeEventListener("keydown", onKeyDown);
- };
+const EraserTool = (canvas, contentStateRef, setContentState) => {
+ const getState = () => contentStateRef.current;
- // Eraser that deletes objects as the cursor moves (and while it is clicked, dragging) over them
- // Store objecs in an array, then delete them on mouse up
let objectsToDelete = [];
let isDown = false;
- if (tool.tool === "eraser") {
- // Make all objects unselectable. If a group, only set the group to unselectable, not the objects inside
+ const setEraserHitTestMode = (enabled) => {
+ // enabled: perPixelTargetFind true, selectable false
canvas.forEachObject((object) => {
- object.set({ selectable: false, perPixelTargetFind: true });
+ object.set({
+ selectable: false,
+ perPixelTargetFind: enabled ? true : false,
+ });
});
+ };
- canvas.renderAll();
- }
-
- // Mouse down
const onMouseDown = (o) => {
- if (tool.tool !== "eraser") return;
- objectsToDelete = [];
+ const state = getState();
+ if (!state?.drawingMode) return;
+ if (state.tool !== "eraser") return;
+ objectsToDelete = [];
isDown = true;
- if (!o.target) return;
+ setEraserHitTestMode(true);
- // Make all objects unselectable. If a group, only set the group to unselectable, not the objects inside
- canvas.forEachObject((object) => {
- object.set({ selectable: false, perPixelTargetFind: true });
- });
+ if (!o.target) return;
- // Add object to array, and set its opacity to .5
objectsToDelete.push(o.target);
o.target.set({ opacity: 0.5 });
- canvas.renderAll();
+ canvas.requestRenderAll();
};
- // Mouse move
const onMouseMove = (o) => {
- if (tool.tool !== "eraser") return;
-
- // Make all objects unselectable. If a group, only set the group to unselectable, not the objects inside
- canvas.forEachObject((object) => {
- object.set({ selectable: false, perPixelTargetFind: true });
- });
+ const state = getState();
+ if (!state?.drawingMode) return;
+ if (state.tool !== "eraser") return;
if (!isDown) return;
if (!o.target) return;
- // Add object to array, and set its opacity to .5
- objectsToDelete.push(o.target);
- o.target.set({ opacity: 0.5 });
+ // avoid duplicates (optional but nice)
+ if (!objectsToDelete.includes(o.target)) {
+ objectsToDelete.push(o.target);
+ o.target.set({ opacity: 0.5 });
+ }
- canvas.renderAll();
+ canvas.requestRenderAll();
};
- // Mouse up
- const onMouseUp = (o) => {
- if (tool.tool !== "eraser") return;
- // Delete all objects in the array. Make sure to delete groups
+ const onMouseUp = () => {
+ const state = getState();
+ if (!state?.drawingMode) return;
+ if (state.tool !== "eraser") return;
+
+ // delete collected
objectsToDelete.forEach((object) => {
+ if (!object) return;
+
if (object.type === "group") {
- // If object is a group, delete it and all objects inside
- object.forEachObject((object) => {
- canvas.remove(object);
- });
+ // remove group children then group
+ object._objects?.forEach((child) => canvas.remove(child));
canvas.remove(object);
} else {
canvas.remove(object);
}
});
- canvas.renderAll();
+ // restore opacities if any remained (in case duplicates / removed objects)
+ canvas.getObjects().forEach((obj) => {
+ if (obj?.opacity === 0.5) obj.set({ opacity: 1 });
+ });
objectsToDelete = [];
isDown = false;
- // Make all objects on the canvas selectable
- canvas.forEachObject((object) => {
- object.set({ selectable: true, perPixelTargetFind: false });
- });
+ // Selection logic is handled by your CanvasWrap effect (based on tool),
+ // so we don't force selectable=true here.
+ canvas.requestRenderAll();
- saveCanvas(toolSettings, setToolSettings);
+ saveCanvas(contentStateRef, setContentState);
};
- // Detect pressing the delete or backspace key
const onKeyDown = (e) => {
- if (e.keyCode === 8 || e.keyCode === 46) {
- // if multiple objects are selected
- const activeGroup = canvas.getActiveObjects();
+ const state = getState();
+ if (!state?.drawingMode) return;
+ if (state.tool !== "eraser") return;
+
+ if (e.key === "Backspace" || e.key === "Delete") {
+ const activeObjects = canvas.getActiveObjects();
const activeObject = canvas.getActiveObject();
- if (activeGroup & !activeObject) {
- if (activeGroup.isEditing) return;
+ // If text editing, don't delete
+ if (activeObject?.isEditing) return;
+
+ if (activeObjects && activeObjects.length > 1 && !activeObject) {
canvas.discardActiveObject();
- activeGroup.forEach((object) => {
- canvas.remove(object);
- });
- saveCanvas(toolSettings, setToolSettings);
+ activeObjects.forEach((obj) => canvas.remove(obj));
+ saveCanvas(contentStateRef, setContentState);
+ canvas.requestRenderAll();
+ return;
}
if (activeObject) {
- // Check if not in text editing mode
- if (activeObject.isEditing) return;
canvas.remove(activeObject);
- saveCanvas(toolSettings, setToolSettings);
+ saveCanvas(contentStateRef, setContentState);
+ canvas.requestRenderAll();
}
}
};
- // Add event listeners
+ // Attach listeners once
document.addEventListener("keydown", onKeyDown);
canvas.on("mouse:down", onMouseDown);
canvas.on("mouse:move", onMouseMove);
canvas.on("mouse:up", onMouseUp);
return {
- removeEventListeners,
+ removeEventListeners: () => {
+ canvas.off("mouse:down", onMouseDown);
+ canvas.off("mouse:move", onMouseMove);
+ canvas.off("mouse:up", onMouseUp);
+ document.removeEventListener("keydown", onKeyDown);
+ },
};
};
diff --git a/src/pages/Content/canvas/modules/History.jsx b/src/pages/Content/canvas/modules/History.jsx
index 4db0bfd..41225a7 100644
--- a/src/pages/Content/canvas/modules/History.jsx
+++ b/src/pages/Content/canvas/modules/History.jsx
@@ -1,57 +1,70 @@
import { fabric } from "fabric";
+const getState = (stateOrRef) =>
+ stateOrRef && stateOrRef.current ? stateOrRef.current : stateOrRef;
+
// Undo and redo functionality for Fabric.js
-const undoCanvas = (toolSettings, setToolSettings) => {
- if (!toolSettings.canvas) return;
- const canvas = toolSettings.canvas;
- if (toolSettings.undoStack.length > 0) {
- const undoStack = [...toolSettings.undoStack];
- const redoStack = [...toolSettings.redoStack];
+const undoCanvas = (stateOrRef, setToolSettings) => {
+ const state = getState(stateOrRef);
+ if (!state?.canvas) return;
+
+ const canvas = state.canvas;
+
+ if (state.undoStack?.length > 0) {
+ const undoStack = [...state.undoStack];
+ const redoStack = [...(state.redoStack || [])];
+
const lastItem = undoStack.pop();
redoStack.push(lastItem);
- // penultimate item is the last item before the last item
+
const penultimateItem = undoStack[undoStack.length - 1];
+ if (!penultimateItem) {
+ // nothing meaningful to load
+ setToolSettings({ ...state, undoStack, redoStack });
+ return;
+ }
+
canvas.clear();
canvas.renderAll();
+
canvas.loadFromJSON(penultimateItem, () => {
- // De-select everything
canvas.discardActiveObject();
canvas.renderAll();
});
- setToolSettings({
- ...toolSettings,
- undoStack,
- redoStack,
- });
+
+ setToolSettings({ ...state, undoStack, redoStack });
}
};
-const redoCanvas = (toolSettings, setToolSettings) => {
- if (!toolSettings.canvas) return;
- const canvas = toolSettings.canvas;
- if (toolSettings.redoStack.length > 0) {
- const undoStack = [...toolSettings.undoStack];
- const redoStack = [...toolSettings.redoStack];
+const redoCanvas = (stateOrRef, setToolSettings) => {
+ const state = getState(stateOrRef);
+ if (!state?.canvas) return;
+
+ const canvas = state.canvas;
+
+ if (state.redoStack?.length > 0) {
+ const undoStack = [...(state.undoStack || [])];
+ const redoStack = [...state.redoStack];
+
const lastItem = redoStack.pop();
undoStack.push(lastItem);
+
canvas.loadFromJSON(lastItem, () => {
- // De-select everything
canvas.discardActiveObject();
canvas.renderAll();
});
- setToolSettings({
- ...toolSettings,
- undoStack,
- redoStack,
- });
+
+ setToolSettings({ ...state, undoStack, redoStack });
}
};
-const saveCanvas = (toolSettings, setToolSettings) => {
- if (!toolSettings.canvas) return;
- const canvas = toolSettings.canvas;
+const saveCanvas = (stateOrRef, setToolSettings) => {
+ const state = getState(stateOrRef);
+ if (!state?.canvas) return;
+
+ const canvas = state.canvas;
- let json = canvas.toJSON([
+ const json = canvas.toJSON([
"id",
"selectable",
"evented",
@@ -66,19 +79,19 @@ const saveCanvas = (toolSettings, setToolSettings) => {
]);
const jsonString = JSON.stringify(json);
- const undoStack = [...toolSettings.undoStack, jsonString];
+ const undoStack = [...(state.undoStack || []), jsonString];
+
setToolSettings({
- ...toolSettings,
+ ...state,
undoStack,
redoStack: [],
});
};
-const checkChanges = (canvas, toolSettings, setToolSettings) => {
- // Check when objects are modified (after action is completed) to save the canvas
-
- const onChange = (e) => {
- saveCanvas(toolSettings, setToolSettings);
+const checkChanges = (canvas, stateRef, setToolSettings) => {
+ const onChange = () => {
+ // always save with latest state
+ saveCanvas(stateRef, setToolSettings);
};
canvas.on("object:modified", onChange);
diff --git a/src/pages/Content/canvas/modules/PenTool.jsx b/src/pages/Content/canvas/modules/PenTool.jsx
index 42be30f..399a363 100644
--- a/src/pages/Content/canvas/modules/PenTool.jsx
+++ b/src/pages/Content/canvas/modules/PenTool.jsx
@@ -1,116 +1,162 @@
import { fabric } from "fabric";
-const PenTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
- if (toolSettings.tool === "pen") {
- canvas.isDrawingMode = true;
- canvas.freeDrawingBrush.drawStraightLine = false;
- canvas.freeDrawingBrush.width = toolSettings.strokeWidth * 4;
- canvas.freeDrawingBrush.color = toolSettings.color;
- canvas.freeDrawingBrush.straightLineKey = "none";
- } else if (toolSettings.tool === "highlighter") {
- canvas.isDrawingMode = true;
- canvas.freeDrawingBrush.drawStraightLine = false;
- canvas.freeDrawingBrush.straightLineKey = "none";
- canvas.freeDrawingBrush.width = toolSettings.strokeWidth * 10;
- // Make the highlighter transparent
- canvas.freeDrawingBrush.color = new fabric.Color(toolSettings.color)
- .setAlpha(0.5)
- .toRgba();
- // Make the highlighter not draw on top of existing objects
- canvas.freeDrawingBrush.globalCompositeOperation = "destination-over";
- // Make the highlighter brush tip square
- canvas.freeDrawingBrush.strokeLineCap = "square";
- } else {
- canvas.isDrawingMode = false;
- }
-
- const onMouseUp = (o) => {
- if (toolSettings.tool !== "pen" && toolSettings.tool !== "highlighter")
+const PenTool = (canvas, contentStateRef, setContentState, saveCanvas) => {
+ const getState = () => contentStateRef.current;
+
+ const resetBrushStroke = () => {
+ const brush = canvas.freeDrawingBrush;
+ if (!brush) return;
+
+ // Fabric versions differ; do all safe resets.
+ if (Array.isArray(brush._points)) brush._points.length = 0;
+ if (Array.isArray(brush.points)) brush.points.length = 0;
+
+ // Some brushes keep a "latest" pointer
+ brush._reset && brush._reset();
+ };
+
+ const ensureBrush = () => {
+ // fabric creates freeDrawingBrush lazily; make sure it's there
+ if (!canvas.freeDrawingBrush) {
+ canvas.freeDrawingBrush = new fabric.PencilBrush(canvas);
+ }
+ return canvas.freeDrawingBrush;
+ };
+
+ const syncBrushFromState = () => {
+ const state = getState();
+ if (!state) return;
+
+ const brush = ensureBrush();
+
+ // reset defaults
+ brush.drawStraightLine = false;
+ brush.straightLineKey = "none";
+ brush.strokeLineCap = "round";
+ brush.globalCompositeOperation = "source-over";
+
+ if (state.tool === "pen") {
+ brush.width = (state.strokeWidth || 2) * 4;
+ brush.color = state.color;
+ resetBrushStroke();
return;
- saveCanvas(toolSettings, setToolSettings);
+ }
+
+ if (state.tool === "highlighter") {
+ brush.width = (state.strokeWidth || 2) * 10;
+ brush.color = new fabric.Color(state.color).setAlpha(0.5).toRgba();
+ brush.globalCompositeOperation = "destination-over";
+ brush.strokeLineCap = "square";
+ resetBrushStroke();
+ }
+ };
+
+ // Sync brush on interactions so tool switches apply immediately
+ const onMouseDown = () => {
+ syncBrushFromState();
+ };
+
+ const onMouseUp = () => {
+ const state = getState();
+ if (!state) return;
+ if (state.tool !== "pen" && state.tool !== "highlighter") return;
+
+ // Save with latest state
+ // If you updated saveCanvas to accept ref, use: saveCanvas(contentStateRef, setContentState)
+ saveCanvas(state, setContentState);
};
const onPathCreated = (o) => {
- // Make a copy of the path with a thin blue stroke. Then group the two paths together
+ // Only wrap paths if we were drawing (pen/highlighter)
+ const state = getState();
+ if (!state) return;
+ if (state.tool !== "pen" && state.tool !== "highlighter") return;
+
const path = o.path;
+ if (!path) return;
+
const pathCopy = new fabric.Path(path.path, {
id: "select-stroke",
stroke: "#0D99FF",
strokeWidth: 2,
fill: null,
opacity: 0,
+ selectable: false,
+ evented: false,
});
+
const group = new fabric.Group([path, pathCopy], {
- // Make the group selectable
selectable: true,
+ evented: true,
id: "select-group",
+ subTargetCheck: true,
+ perPixelTargetFind: true,
+ hasControls: false,
+ hasBorders: false,
});
+
canvas.add(group);
- // Remove the original path from the canvas
canvas.remove(path);
- canvas.renderAll();
+ canvas.requestRenderAll();
};
- const activateStroke = (o) => {
- if (toolSettings.tool !== "select") return;
-
+ const hideAllSelectStrokes = () => {
canvas.getObjects().forEach((obj) => {
- if (obj.type == "group") {
- obj._objects.forEach((obj2) => {
- if (obj2.id === "select-stroke") {
- obj2.set({ opacity: 0 });
- canvas.renderAll();
- }
+ if (obj.type === "group") {
+ obj._objects?.forEach((child) => {
+ if (child.id === "select-stroke") child.set({ opacity: 0 });
});
}
});
+ };
+
+ const activateStroke = () => {
+ const state = getState();
+ if (!state) return;
+ if (state.tool !== "select") return;
+
+ hideAllSelectStrokes();
const activeObject = canvas.getActiveObject();
if (activeObject && activeObject.id === "select-group") {
- activeObject._objects.forEach((obj) => {
- if (obj.id === "select-stroke") {
- obj.set({ opacity: 1 });
- }
+ activeObject._objects?.forEach((child) => {
+ if (child.id === "select-stroke") child.set({ opacity: 1 });
});
- canvas.renderAll();
}
- // Also if multiple selected objects, show the blue border in all of them
- const activeGroup = canvas.getActiveObjects();
- if (activeGroup && activeGroup.length > 1) {
- activeGroup.forEach((obj) => {
+ const activeObjects = canvas.getActiveObjects();
+ if (activeObjects && activeObjects.length > 1) {
+ activeObjects.forEach((obj) => {
if (obj.id === "select-group") {
- obj._objects.forEach((obj) => {
- if (obj.id === "select-stroke") {
- obj.set({ opacity: 1 });
- }
+ obj._objects?.forEach((child) => {
+ if (child.id === "select-stroke") child.set({ opacity: 1 });
});
}
});
- canvas.renderAll();
}
+
+ canvas.requestRenderAll();
};
- const deactivateStroke = (o) => {
- canvas.getObjects().forEach((obj) => {
- if (obj.type == "group") {
- obj._objects.forEach((obj2) => {
- if (obj2.id === "select-stroke") {
- obj2.set({ opacity: 0 });
- canvas.renderAll();
- }
- });
- }
- });
+
+ const deactivateStroke = () => {
+ hideAllSelectStrokes();
+ canvas.requestRenderAll();
};
+ // Attach once
+ canvas.on("mouse:down", onMouseDown);
canvas.on("mouse:up", onMouseUp);
canvas.on("path:created", onPathCreated);
canvas.on("selection:created", activateStroke);
canvas.on("selection:updated", activateStroke);
canvas.on("selection:cleared", deactivateStroke);
+ // Initial sync
+ syncBrushFromState();
+
return {
removeEventListeners: () => {
+ canvas.off("mouse:down", onMouseDown);
canvas.off("mouse:up", onMouseUp);
canvas.off("path:created", onPathCreated);
canvas.off("selection:created", activateStroke);
diff --git a/src/pages/Content/canvas/modules/SelectTool.jsx b/src/pages/Content/canvas/modules/SelectTool.jsx
index 43cf08d..d71a5cd 100644
--- a/src/pages/Content/canvas/modules/SelectTool.jsx
+++ b/src/pages/Content/canvas/modules/SelectTool.jsx
@@ -1,101 +1,81 @@
import { fabric } from "fabric";
-const SelectTool = (canvas, toolSettings, setToolSettings) => {
- if (toolSettings.tool === "select") {
- // Check if there's any objects on the canvas
- if (canvas.getObjects().length > 0) {
- // Make all objects on the canvas selectable
- canvas.forEachObject((object) => {
- object.set({ selectable: true, perPixelTargetFind: false });
- });
-
- // Make canvas selectable
- canvas.selection = true;
- canvas.renderAll();
- }
- } else {
- // Make canvas unselectable
- canvas.selection = false;
- canvas.renderAll();
- }
+const SelectTool = (canvas, contentStateRef, setContentState) => {
+ const getState = () => contentStateRef.current;
// On mouse over object
const onMouseOver = (o) => {
- if (toolSettings.tool !== "select") return;
- if (toolSettings.isAddingImage) return;
+ const state = getState();
+ if (!state) return;
+ if (state.tool !== "select") return;
+ if (state.isAddingImage) return;
if (!o.target) return;
- if (o.target != canvas.getActiveObject()) {
+ if (o.target !== canvas.getActiveObject()) {
if (o.target.type === "group" && o.target.id === "select-group") {
- // Find child of group with ID "select-stroke"
- const selectStroke = o.target._objects.find(
- (object) => object.id === "select-stroke"
+ const selectStroke = o.target._objects?.find(
+ (object) => object.id === "select-stroke",
);
- selectStroke.set({ opacity: 1 });
+ if (selectStroke) selectStroke.set({ opacity: 1 });
} else if (o.target.type === "group" && o.target.id === "arrowGroup") {
- o.target._objects.forEach((obj) => {
- if (obj.id === "arrowLineControl") {
- obj.set({ opacity: 1 });
- }
+ o.target._objects?.forEach((obj) => {
+ if (obj.id === "arrowLineControl") obj.set({ opacity: 1 });
});
} else {
+ // draws fabric controls on the top context
o.target._renderControls(o.target.canvas.contextTop, {
hasControls: false,
});
}
- canvas.renderAll();
+ canvas.requestRenderAll();
}
-
- // Show blue border on hover
- // o.target.set({ stroke: "blue", strokeWidth: 2 });
- //canvas.renderAll();
};
// On mouse out object
const onMouseOut = (o) => {
- if (toolSettings.tool !== "select") return;
+ const state = getState();
+ if (!state) return;
+ if (state.tool !== "select") return;
if (!o.target) return;
- if (o.target != canvas.getActiveObject()) {
+ if (o.target !== canvas.getActiveObject()) {
if (o.target.type === "group" && o.target.id === "select-group") {
- // Find child of group with ID "select-stroke"
- const selectStroke = o.target._objects.find(
- (object) => object.id === "select-stroke"
+ const selectStroke = o.target._objects?.find(
+ (object) => object.id === "select-stroke",
);
- selectStroke.set({ opacity: 0 });
- canvas.renderAll();
+ if (selectStroke) selectStroke.set({ opacity: 0 });
} else if (o.target.type === "group" && o.target.id === "arrowGroup") {
- o.target._objects.forEach((obj) => {
- if (obj.id === "arrowLineControl") {
- obj.set({ opacity: 0 });
- }
+ o.target._objects?.forEach((obj) => {
+ if (obj.id === "arrowLineControl") obj.set({ opacity: 0 });
});
- canvas.renderAll();
}
}
- o.target.canvas.clearContext(o.target.canvas.contextTop);
- canvas.renderAll();
+ if (o.target?.canvas?.contextTop) {
+ o.target.canvas.clearContext(o.target.canvas.contextTop);
+ }
+ canvas.requestRenderAll();
};
- const checkObject = (o) => {
- if (toolSettings.isAddingImage) return;
- if (toolSettings.tool !== "select") return;
- if (!o.target) return;
- if (!o.target.canvas) return;
+ const onMouseDown = (o) => {
+ const state = getState();
+ if (!state) return;
+ if (state.isAddingImage) return;
+ if (state.tool !== "select") return;
+ if (!o.target?.canvas?.contextTop) return;
o.target.canvas.clearContext(o.target.canvas.contextTop);
};
canvas.on("mouse:over", onMouseOver);
canvas.on("mouse:out", onMouseOut);
- canvas.on("mouse:down", checkObject);
+ canvas.on("mouse:down", onMouseDown);
return {
removeEventListeners: function () {
canvas.off("mouse:over", onMouseOver);
canvas.off("mouse:out", onMouseOut);
- canvas.off("mouse:down", checkObject);
+ canvas.off("mouse:down", onMouseDown);
},
};
};
diff --git a/src/pages/Content/canvas/modules/ShapeTool.jsx b/src/pages/Content/canvas/modules/ShapeTool.jsx
index c222ca1..93bd383 100644
--- a/src/pages/Content/canvas/modules/ShapeTool.jsx
+++ b/src/pages/Content/canvas/modules/ShapeTool.jsx
@@ -1,101 +1,131 @@
-import React from "react";
-
import { fabric } from "fabric";
-const ShapeTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
- const tool = toolSettings;
- let shape;
+const ShapeTool = (canvas, contentStateRef, setContentState, saveCanvas) => {
+ const getState = () => contentStateRef.current;
+
+ let shape = null;
let isDown = false;
- let origX;
- let origY;
+ let origX = 0;
+ let origY = 0;
- const onMouseDown = (o) => {
- if (tool.tool !== "shape") return;
- isDown = true;
- const pointer = canvas.getPointer(o.e);
- origX = pointer.x;
- origY = pointer.y;
- if (tool.shape === "rectangle") {
- shape = new fabric.Rect({
+ const makeShape = (state, pointer) => {
+ const color = state.color;
+ const strokeWidth = (state.strokeWidth || 2) * 6;
+ const fill = state.shapeFill ? color : "transparent";
+
+ if (state.shape === "rectangle") {
+ return new fabric.Rect({
left: origX,
top: origY,
originX: "left",
originY: "top",
- width: pointer.x - origX,
- height: pointer.y - origY,
+ width: 0,
+ height: 0,
strokeUniform: true,
angle: 0,
- fill: tool.shapeFill ? toolSettings.color : "transparent",
+ fill,
noScaleCache: false,
- stroke: toolSettings.color,
- strokeWidth: toolSettings.strokeWidth * 6,
+ stroke: color,
+ strokeWidth,
});
- } else if (tool.shape === "triangle") {
- shape = new fabric.Triangle({
+ }
+
+ if (state.shape === "triangle") {
+ return new fabric.Triangle({
left: origX,
top: origY,
originX: "left",
originY: "top",
strokeMilterLimit: 8,
objectCaching: false,
- width: pointer.x - origX,
- height: pointer.y - origY,
- strokeUniform: true,
- angle: 0,
- fill: tool.shapeFill ? toolSettings.color : "transparent",
- noScaleCache: false,
- stroke: toolSettings.color,
- strokeWidth: toolSettings.strokeWidth * 6,
- });
- } else if (tool.shape === "circle") {
- shape = new fabric.Circle({
- left: origX,
- top: origY,
- originX: "left",
- originY: "top",
- radius: Math.abs(pointer.x - origX) / 2,
+ width: 0,
+ height: 0,
strokeUniform: true,
angle: 0,
- fill: tool.shapeFill ? toolSettings.color : "transparent",
+ fill,
noScaleCache: false,
- stroke: toolSettings.color,
- strokeWidth: toolSettings.strokeWidth * 6,
+ stroke: color,
+ strokeWidth,
});
}
+
+ // circle
+ return new fabric.Circle({
+ left: origX,
+ top: origY,
+ originX: "left",
+ originY: "top",
+ radius: 0,
+ strokeUniform: true,
+ angle: 0,
+ fill,
+ noScaleCache: false,
+ stroke: color,
+ strokeWidth,
+ });
+ };
+
+ const onMouseDown = (o) => {
+ const state = getState();
+ if (!state?.drawingMode) return;
+ if (state.tool !== "shape") return;
+
+ isDown = true;
+
+ const pointer = canvas.getPointer(o.e);
+ origX = pointer.x;
+ origY = pointer.y;
+
+ shape = makeShape(state, pointer);
canvas.add(shape);
+ canvas.requestRenderAll();
};
const onMouseMove = (o) => {
- if (tool.tool !== "shape") return;
- if (!isDown) return;
+ const state = getState();
+ if (!state?.drawingMode) return;
+ if (state.tool !== "shape") return;
+ if (!isDown || !shape) return;
+
const pointer = canvas.getPointer(o.e);
- if (origX > pointer.x) {
- shape.set({ left: Math.abs(pointer.x) });
- }
- if (origY > pointer.y) {
- shape.set({ top: Math.abs(pointer.y) });
- }
+ // Handle dragging “backwards”
+ const left = Math.min(origX, pointer.x);
+ const top = Math.min(origY, pointer.y);
+ const w = Math.abs(pointer.x - origX);
+ const h = Math.abs(pointer.y - origY);
- if (tool.shape === "rectangle" || tool.shape === "triangle") {
- shape.set({ width: Math.abs(origX - pointer.x) });
- shape.set({ height: Math.abs(origY - pointer.y) });
- } else if (tool.shape === "circle") {
- shape.set({
- radius: Math.abs(pointer.x - origX) / 2,
- });
+ shape.set({ left, top });
+
+ if (state.shape === "rectangle" || state.shape === "triangle") {
+ shape.set({ width: w, height: h });
+ } else if (state.shape === "circle") {
+ // Use min dimension so it stays circular
+ const r = Math.min(w, h) / 2;
+ shape.set({ radius: r });
}
+ shape.setCoords();
canvas.requestRenderAll();
};
- const onMouseUp = (o) => {
- if (tool.tool !== "shape") return;
+ const onMouseUp = () => {
+ const state = getState();
+ if (!state?.drawingMode) return;
+ if (state.tool !== "shape") return;
+ if (!isDown) return;
+
isDown = false;
- canvas.renderAll();
- saveCanvas({ ...toolSettings, tool: "select" }, setToolSettings);
- canvas.setActiveObject(shape);
- canvas.renderAll();
+
+ canvas.requestRenderAll();
+
+ // Save with latest state (not stale snapshot)
+ saveCanvas({ ...state, tool: "select" }, setContentState);
+
+ if (shape) {
+ canvas.setActiveObject(shape);
+ canvas.requestRenderAll();
+ }
};
canvas.on("mouse:down", onMouseDown);
@@ -103,7 +133,7 @@ const ShapeTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
canvas.on("mouse:up", onMouseUp);
return {
- removeEventListeners: function () {
+ removeEventListeners: () => {
canvas.off("mouse:down", onMouseDown);
canvas.off("mouse:move", onMouseMove);
canvas.off("mouse:up", onMouseUp);
diff --git a/src/pages/Content/canvas/modules/TextTool.jsx b/src/pages/Content/canvas/modules/TextTool.jsx
index a85d748..83ce06b 100644
--- a/src/pages/Content/canvas/modules/TextTool.jsx
+++ b/src/pages/Content/canvas/modules/TextTool.jsx
@@ -1,9 +1,43 @@
import { fabric } from "fabric";
-const TextTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
- // Add interactive text on click, start editing
+const TextTool = (canvas, contentStateRef, setContentState, saveCanvas) => {
+ const getState = () => contentStateRef.current;
+
+ // Track the currently-created textbox so we can finalize it cleanly
+ let activeCreatedText = null;
+
+ const finalizeIfNeeded = () => {
+ if (!activeCreatedText) return;
+
+ const text = activeCreatedText;
+ const currentActive = canvas.getActiveObject();
+
+ // If user clicked away / ended editing
+ if (currentActive !== text) {
+ if ((text.text || "").trim() === "") {
+ canvas.remove(text);
+ } else {
+ // Save using latest state
+ saveCanvas({ ...getState(), canvas }, setContentState);
+ }
+ activeCreatedText = null;
+ canvas.requestRenderAll();
+ }
+ };
+
+ const onCanvasMouseDownCapture = (o) => {
+ // This runs on any mouse down to potentially finalize the last text.
+ // But don't interfere if user is still editing that text.
+ finalizeIfNeeded();
+ };
+
const onMouseDown = (o) => {
- if (toolSettings.tool !== "text") return;
+ const state = getState();
+ if (!state?.drawingMode) return;
+ if (state.tool !== "text") return;
+
+ // Before creating a new one, finalize previous if any
+ finalizeIfNeeded();
const pointer = canvas.getPointer(o.e);
const x = pointer.x;
@@ -14,7 +48,7 @@ const TextTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
top: y,
fontFamily: "Satoshi-Medium",
fontSize: 20,
- fill: toolSettings.color,
+ fill: state.color,
fontWeight: "normal",
fontStyle: "normal",
originX: "left",
@@ -25,111 +59,90 @@ const TextTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
skipAutoWidthAdjustment: false,
perPixelTargetFind: false,
});
- // Blue selection box while editing
+
text.on("editing:entered", () => {
text.borderColor = "#0D99FF";
});
canvas.add(text);
canvas.setActiveObject(text);
+
+ // Start editing
text.enterEditing();
text.selectAll();
- // Set tool back to cursor
- setToolSettings({
- ...toolSettings,
+ activeCreatedText = text;
+
+ // Set tool back to select (use latest state)
+ setContentState((prev) => ({
+ ...prev,
tool: "select",
- });
+ }));
- // When user clicks off of text, save canvas
- canvas.on("mouse:down", () => {
- if (canvas.getActiveObject() !== text) {
- // Check if text is empty, if so, remove it
- if (text.text === "") {
- canvas.remove(text);
- } else {
- saveCanvas(canvas);
- }
- }
- });
+ canvas.requestRenderAll();
};
const onKeyPress = (event) => {
- if (canvas.getActiveObject() === null) return;
- // check if getactiveobject is an object
- if (typeof canvas.getActiveObject() !== "object") return;
-
- // Check if the active object is a textbox and if the user is editing it
- if (
- canvas.getActiveObject().type !== "textbox" ||
- !canvas.getActiveObject().isEditing
- )
- return;
+ const obj = canvas.getActiveObject();
+ if (!obj || typeof obj !== "object") return;
+
+ if (obj.type !== "textbox" || !obj.isEditing) return;
- // Get the active text object
- var text = canvas.getActiveObject();
+ const text = obj;
- // Check if the user has explicitly set the width of the textbox
+ // If user explicitly resized, skip
if (text.skipAutoWidthAdjustment) return;
- // Get text in current line of text
- var currentLine = text._textLines[text._textLines.length - 1];
- // current line to string
- currentLine = currentLine.join("");
+ // Guard: _textLines might not exist at some moments
+ const lines = text._textLines || [];
+ if (lines.length === 0) return;
- // Check if the user is backspacing
- if (event.keyCode === 8 && currentLine.length > 0) {
- // Remove the last character from the current line
+ let currentLine = lines[lines.length - 1].join("");
+
+ // Backspace
+ if (event.key === "Backspace" && currentLine.length > 0) {
currentLine = currentLine.slice(0, -1);
+ } else if (event.key && event.key.length === 1) {
+ currentLine += event.key;
} else {
- // Add the pressed character to the current line
- var charCode = event.charCode || event.keyCode;
- var character = String.fromCharCode(charCode);
- currentLine += character;
+ // ignore other keys
+ return;
}
- var newText = currentLine;
+ // Measure
+ const tempCanvas = document.createElement("canvas");
+ const tempCtx = tempCanvas.getContext("2d");
+ tempCtx.font = `${text.fontSize}px ${text.fontFamily}`;
+ const textMetrics = tempCtx.measureText(currentLine);
- // Create a temporary canvas to measure the text width
- var tempCanvas = document.createElement("canvas");
- var tempCtx = tempCanvas.getContext("2d");
- tempCtx.font = text.fontSize + "px " + text.fontFamily;
- var textMetrics = tempCtx.measureText(newText);
+ const maxLineWidth = getMaxLineWidth(lines, text);
- // Adjust the width of the text if necessary
- var textWidth = Math.max(text.width, textMetrics.width + 2);
+ // Expand width if needed
if (textMetrics.width > text.width) {
+ const nextWidth = Math.max(text.width, textMetrics.width + 2);
text.set({
- left: text.left - (textWidth - text.width) / 2,
+ left: text.left - (nextWidth - text.width) / 2,
+ width: nextWidth,
+ });
+ } else if (textMetrics.width < maxLineWidth) {
+ text.set({
+ left: text.left + (text.width - maxLineWidth) / 2,
+ width: maxLineWidth,
});
-
- canvas.renderAll();
- text.set("width", textWidth);
- } else {
- var maxLineWidth = getMaxLineWidth(text._textLines, text);
- if (textMetrics.width < maxLineWidth) {
- text.set({
- left: text.left + (text.width - maxLineWidth) / 2,
- });
-
- canvas.renderAll();
- text.set("width", maxLineWidth);
- }
}
- canvas.renderAll();
+ canvas.requestRenderAll();
};
function getMaxLineWidth(textLines, text) {
- var maxLineWidth = 0;
- var tempCanvas = document.createElement("canvas");
- var tempCtx = tempCanvas.getContext("2d");
- tempCtx.font = text.fontSize + "px " + text.fontFamily;
-
- for (var i = 0; i < textLines.length; i++) {
- var line = textLines[i].join("");
- var lineMetrics = tempCtx.measureText(line);
- var lineWidth = lineMetrics.width;
+ let maxLineWidth = 0;
+ const tempCanvas = document.createElement("canvas");
+ const tempCtx = tempCanvas.getContext("2d");
+ tempCtx.font = `${text.fontSize}px ${text.fontFamily}`;
+
+ for (let i = 0; i < textLines.length; i++) {
+ const line = textLines[i].join("");
+ const lineWidth = tempCtx.measureText(line).width;
maxLineWidth = Math.max(maxLineWidth, lineWidth);
}
@@ -137,44 +150,41 @@ const TextTool = (canvas, toolSettings, setToolSettings, saveCanvas) => {
}
const onResize = (e) => {
- // Check if the active object is a textbox
- if (e.target.type !== "textbox") return;
-
- // Set flag to skip auto width adjustment
- var text = e.target;
- text.skipAutoWidthAdjustment = true;
- canvas.renderAll();
+ if (e?.target?.type !== "textbox") return;
+ e.target.skipAutoWidthAdjustment = true;
+ canvas.requestRenderAll();
};
- canvas.on("mouse:down", onMouseDown);
- document.addEventListener("keydown", onKeyPress);
- canvas.on("object:resizing", onResize);
- canvas.on("mouse:move", function (event) {
- var pointer = canvas.getPointer(event.e);
- var isHoveringTextbox = false;
+ // Hover logic: DON'T use anonymous mouse:move that you later nuke.
+ const onMouseMove = (event) => {
+ const pointer = canvas.getPointer(event.e);
+ let hoveringTextbox = false;
- canvas.forEachObject(function (obj) {
+ canvas.forEachObject((obj) => {
if (obj.type === "textbox" && obj.containsPoint(pointer)) {
- isHoveringTextbox = true;
- return false;
+ hoveringTextbox = true;
}
});
- if (isHoveringTextbox) {
- // Disable perPixelTargetFind when hovering over a textbox
- canvas.perPixelTargetFind = false;
- } else {
- // Re-enable perPixelTargetFind when mouse leaves the textbox
- canvas.perPixelTargetFind = true;
- }
- });
+ canvas.perPixelTargetFind = !hoveringTextbox;
+ };
+
+ // Attach listeners once
+ // Note: we attach the “finalize” handler too, but it’s cheap.
+ canvas.on("mouse:down", onCanvasMouseDownCapture);
+ canvas.on("mouse:down", onMouseDown);
+
+ document.addEventListener("keydown", onKeyPress);
+ canvas.on("object:resizing", onResize);
+ canvas.on("mouse:move", onMouseMove);
return {
removeEventListeners: () => {
+ canvas.off("mouse:down", onCanvasMouseDownCapture);
canvas.off("mouse:down", onMouseDown);
document.removeEventListener("keydown", onKeyPress);
canvas.off("object:resizing", onResize);
- canvas.off("mouse:move");
+ canvas.off("mouse:move", onMouseMove);
},
};
};
diff --git a/src/pages/Content/context/ContentState.jsx b/src/pages/Content/context/ContentState.jsx
index 47bd0b0..94110ab 100644
--- a/src/pages/Content/context/ContentState.jsx
+++ b/src/pages/Content/context/ContentState.jsx
@@ -42,10 +42,10 @@ const ContentState = (props) => {
process.env.SCREENITY_ENABLE_CLOUD_FEATURES === "true";
setTimer = setTimerInternal;
const [URL, setURL] = useState(
- "https://help.screenity.io/getting-started/77KizPC8MHVGfpKpqdux9D/why-does-screenity-ask-for-permissions/9AAE8zJ6iiUtCAtjn4SUT1"
+ "https://help.screenity.io/getting-started/77KizPC8MHVGfpKpqdux9D/why-does-screenity-ask-for-permissions/9AAE8zJ6iiUtCAtjn4SUT1",
);
const [URL2, setURL2] = useState(
- "https://help.screenity.io/troubleshooting/9Jy5RGjNrBB42hqUdREQ7W/how-to-grant-screenity-permission-to-record-your-camera-and-microphone/x6U69TnrbMjy5CQ96Er2E9"
+ "https://help.screenity.io/troubleshooting/9Jy5RGjNrBB42hqUdREQ7W/how-to-grant-screenity-permission-to-record-your-camera-and-microphone/x6U69TnrbMjy5CQ96Er2E9",
);
const startBeepRef = useRef(null);
const stopBeepRef = useRef(null);
@@ -122,12 +122,12 @@ const ContentState = (props) => {
setURL(
"https://translate.google.com/translate?sl=en&tl=" +
locale +
- "&u=https://help.screenity.io/getting-started/77KizPC8MHVGfpKpqdux9D/why-does-screenity-ask-for-permissions/9AAE8zJ6iiUtCAtjn4SUT1"
+ "&u=https://help.screenity.io/getting-started/77KizPC8MHVGfpKpqdux9D/why-does-screenity-ask-for-permissions/9AAE8zJ6iiUtCAtjn4SUT1",
);
setURL2(
"https://translate.google.com/translate?sl=en&tl=" +
locale +
- "&u=https://help.screenity.io/troubleshooting/9Jy5RGjNrBB42hqUdREQ7W/how-to-grant-screenity-permission-to-record-your-camera-and-microphone/x6U69TnrbMjy5CQ96Er2E9"
+ "&u=https://help.screenity.io/troubleshooting/9Jy5RGjNrBB42hqUdREQ7W/how-to-grant-screenity-permission-to-record-your-camera-and-microphone/x6U69TnrbMjy5CQ96Er2E9",
);
}
}, []);
@@ -181,7 +181,7 @@ const ContentState = (props) => {
{
type: "restart-recording",
},
- "*"
+ "*",
);
}
if (contentStateRef.current.alarm) {
@@ -222,6 +222,10 @@ const ContentState = (props) => {
chrome.storage.local.set({
restarting: false,
tabRecordedID: null,
+ drawingMode: false,
+ blurMode: false,
+ cursorMode: "none",
+ cursorEffects: [],
});
setContentState((prevContentState) => ({
...prevContentState,
@@ -236,6 +240,11 @@ const ContentState = (props) => {
time: 0,
timer: 0,
preparingRecording: false,
+ drawingMode: false,
+ blurMode: false,
+ toolbarMode: "",
+ cursorMode: "none",
+ cursorEffects: [],
}));
// Remove blur from all elements
const elements = document.querySelectorAll(".screenity-blur");
@@ -265,7 +274,7 @@ const ContentState = (props) => {
if (!dismiss) {
contentStateRef.current.openToast(
chrome.i18n.getMessage("pausedRecordingToast"),
- function () {}
+ function () {},
);
}
}, 100);
@@ -359,7 +368,7 @@ const ContentState = (props) => {
},
(response) => {
resolve(response.status === "ok");
- }
+ },
);
});
}, []);
@@ -393,7 +402,7 @@ const ContentState = (props) => {
() => {
window.open(process.env.SCREENITY_APP_BASE, "_blank");
},
- () => {}
+ () => {},
);
} else if (!success) {
const isSubError = error === "Subscription inactive";
@@ -427,7 +436,7 @@ const ContentState = (props) => {
async () => {
window.location.reload(); // or retry logic
},
- () => {}
+ () => {},
);
}
@@ -462,7 +471,7 @@ const ContentState = (props) => {
null,
chrome.i18n.getMessage("learnMoreDot"),
URL,
- true
+ true,
);
setContentState((prevContentState) => ({
...prevContentState,
@@ -512,7 +521,7 @@ const ContentState = (props) => {
() => {},
null,
chrome.i18n.getMessage("learnMoreDot"),
- helpURL
+ helpURL,
);
}
setContentState((prevContentState) => ({
@@ -537,7 +546,7 @@ const ContentState = (props) => {
width: contentStateRef.current.regionWidth,
height: contentStateRef.current.regionHeight,
},
- "*"
+ "*",
);
}
@@ -584,7 +593,7 @@ const ContentState = (props) => {
askMicrophone: false,
}));
chrome.storage.local.set({ askMicrophone: false });
- }
+ },
);
} else {
chrome.runtime.sendMessage({
@@ -617,7 +626,7 @@ const ContentState = (props) => {
},
() => {
contentState.resumeRecording();
- }
+ },
);
});
@@ -636,7 +645,7 @@ const ContentState = (props) => {
},
() => {
contentStateRef.current.resumeRecording();
- }
+ },
);
} else {
contentStateRef.current.dismissRecording();
@@ -661,12 +670,12 @@ const ContentState = (props) => {
const audioInputById = Array.isArray(audioInput)
? Object.fromEntries(
- audioInput.map((device) => [device.deviceId, device.label])
+ audioInput.map((device) => [device.deviceId, device.label]),
)
: {};
const videoInputById = Array.isArray(videoInput)
? Object.fromEntries(
- videoInput.map((device) => [device.deviceId, device.label])
+ videoInput.map((device) => [device.deviceId, device.label]),
)
: {};
@@ -757,7 +766,7 @@ const ContentState = (props) => {
chrome.i18n.getMessage("learnMoreDot"),
URL2,
true,
- false
+ false,
);
}
}
@@ -1043,7 +1052,7 @@ const ContentState = (props) => {
null,
() => {
chrome.storage.local.set({ firstTimePro: false });
- }
+ },
);
}, 300);
}
@@ -1090,10 +1099,10 @@ const ContentState = (props) => {
chrome.i18n.getMessage("audioWarningTitle"),
chrome.i18n.getMessage(
"audioWarningDescription",
- chrome.i18n.getMessage("tabType")
+ chrome.i18n.getMessage("tabType"),
),
"AudioIcon",
- 10000
+ 10000,
);
// Check if url contains "playground.html" and "chrome-extension://"
} else if (
@@ -1105,7 +1114,7 @@ const ContentState = (props) => {
chrome.i18n.getMessage("extensionNotSupportedTitle"),
chrome.i18n.getMessage("extensionNotSupportedDescription"),
"NotSupportedIcon",
- 10000
+ 10000,
);
}
}
@@ -1146,7 +1155,7 @@ const ContentState = (props) => {
const extraPaused = paused && pausedAt ? Math.max(0, now - pausedAt) : 0;
const elapsedSeconds = Math.max(
0,
- Math.floor((now - recordingStartTime - basePaused - extraPaused) / 1000)
+ Math.floor((now - recordingStartTime - basePaused - extraPaused) / 1000),
);
if (contentStateRef.current?.alarm) {
@@ -1223,7 +1232,7 @@ const ContentState = (props) => {
}
if (changes.cursorEffects) {
const nextEffects = normalizeCursorEffects(
- changes.cursorEffects.newValue
+ changes.cursorEffects.newValue,
);
const fallbackMode =
changes.cursorMode?.newValue ||
@@ -1283,6 +1292,8 @@ const ContentState = (props) => {
}, [contentState.hideToolbar, contentState.hideUI]);
useEffect(() => {
+ if (window.__screenitySetupHandlersInitialized) return;
+ window.__screenitySetupHandlersInitialized = true;
setupHandlers();
}, []);
diff --git a/src/pages/Content/context/messaging/handlers.js b/src/pages/Content/context/messaging/handlers.js
index 3ddb824..4690f39 100644
--- a/src/pages/Content/context/messaging/handlers.js
+++ b/src/pages/Content/context/messaging/handlers.js
@@ -14,6 +14,8 @@ const CLOUD_FEATURES_ENABLED =
const getState = () => contentStateRef.current;
export const setupHandlers = () => {
+ if (window.__screenitySetupHandlersRan) return;
+ window.__screenitySetupHandlersRan = true;
let lastToggleDrawingAt = 0;
const TOGGLE_DRAWING_COOLDOWN_MS = 400;
// Initialize message router
@@ -87,6 +89,26 @@ export const setupHandlers = () => {
drawingMode: nextDrawingMode,
blurMode: nextDrawingMode ? false : prev.blurMode,
}));
+
+ registerMessage("toggle-drawing-mode", () => {
+ const now = Date.now();
+ if (now - lastToggleDrawingAt < TOGGLE_DRAWING_COOLDOWN_MS) return;
+ lastToggleDrawingAt = now;
+ if (document.hidden || !document.hasFocus()) return;
+
+ const nextDrawingMode = !contentStateRef.current.drawingMode;
+
+ setContentState((prev) => ({
+ ...prev,
+ drawingMode: nextDrawingMode,
+ blurMode: nextDrawingMode ? false : prev.blurMode,
+ }));
+
+ chrome.storage.local.set({
+ drawingMode: nextDrawingMode,
+ ...(nextDrawingMode ? { blurMode: false } : {}),
+ });
+ });
});
registerMessage("toggle-blur-mode", () => {
@@ -112,9 +134,7 @@ export const setupHandlers = () => {
}));
chrome.storage.local.set({
hideUI: nextHideUI,
- ...(nextHideUI
- ? { hideToolbar: true, hideUIAlerts: true }
- : {}),
+ ...(nextHideUI ? { hideToolbar: true, hideUIAlerts: true } : {}),
});
});
@@ -151,7 +171,7 @@ export const setupHandlers = () => {
if (isActuallyRecording || pendingRecording) {
// Recording is actually still active - ignore this stale message
console.warn(
- "Ignoring stale recording-ended message - recording still active"
+ "Ignoring stale recording-ended message - recording still active",
);
return;
}
@@ -204,19 +224,19 @@ export const setupHandlers = () => {
if (!message) return;
const startRecordingCommand = message.commands.find(
- (command) => command.name === "start-recording"
+ (command) => command.name === "start-recording",
);
const cancelRecordingCommand = message.commands.find(
- (command) => command.name === "cancel-recording"
+ (command) => command.name === "cancel-recording",
);
const toggleDrawingModeCommand = message.commands.find(
- (command) => command.name === "toggle-drawing-mode"
+ (command) => command.name === "toggle-drawing-mode",
);
const toggleBlurModeCommand = message.commands.find(
- (command) => command.name === "toggle-blur-mode"
+ (command) => command.name === "toggle-blur-mode",
);
const toggleCursorModeCommand = message.commands.find(
- (command) => command.name === "toggle-cursor-mode"
+ (command) => command.name === "toggle-cursor-mode",
);
setContentState((prev) => ({
@@ -297,7 +317,7 @@ export const setupHandlers = () => {
},
() => {
state.dismissRecording();
- }
+ },
);
});
@@ -310,7 +330,7 @@ export const setupHandlers = () => {
message.message ||
"Screen sharing stopped. Stop recording to save your video.",
() => {},
- 10000 // Show for 10 seconds
+ 10000, // Show for 10 seconds
);
}
});
@@ -327,7 +347,7 @@ export const setupHandlers = () => {
},
() => {
state.dismissRecording();
- }
+ },
);
});
@@ -390,7 +410,7 @@ export const setupHandlers = () => {
if (state.openToast) {
state.openToast(
chrome.i18n.getMessage("readyRecordSceneToast"),
- () => {}
+ () => {},
);
}
}, 1000);
@@ -410,7 +430,7 @@ export const setupHandlers = () => {
state.openToast(
chrome.i18n.getMessage("reachingRecordingLimitToast"),
() => {},
- 5000
+ 5000,
);
}
}
@@ -428,7 +448,7 @@ export const setupHandlers = () => {
state.openToast(
chrome.i18n.getMessage("recordingLimitReachedToast"),
() => {},
- 5000
+ 5000,
);
}
}
@@ -488,7 +508,7 @@ export const setupHandlers = () => {
registerMessage("update-project-loading", (message, sender) => {
window.postMessage(
{ source: "update-project-loading", multiMode: message.multiMode },
- "*"
+ "*",
);
if (!message.multiMode) {
@@ -509,7 +529,7 @@ export const setupHandlers = () => {
newProject: message.newProject,
sceneId: message.sceneId,
},
- "*"
+ "*",
);
});
registerMessage("clear-project-recording", (message) => {
diff --git a/src/pages/Content/toolbar/layout/ToolbarWrap.jsx b/src/pages/Content/toolbar/layout/ToolbarWrap.jsx
index 75bd89e..f48a5b6 100644
--- a/src/pages/Content/toolbar/layout/ToolbarWrap.jsx
+++ b/src/pages/Content/toolbar/layout/ToolbarWrap.jsx
@@ -326,20 +326,28 @@ const ToolbarWrap = () => {
}
}, [contentState.drawingMode, contentState.blurMode, contentState.openToast]);
- useEffect(() => {
- let nextMode = modeRef.current;
- if (contentState.drawingMode) {
- nextMode = "draw";
- } else if (contentState.blurMode) {
- nextMode = "blur";
- } else if (modeRef.current === "draw" || modeRef.current === "blur") {
- nextMode = "";
- }
+ // useEffect(() => {
+ // let nextMode = modeRef.current;
+ // if (contentState.drawingMode) {
+ // nextMode = "draw";
+ // } else if (contentState.blurMode) {
+ // nextMode = "blur";
+ // } else if (modeRef.current === "draw" || modeRef.current === "blur") {
+ // nextMode = "";
+ // }
+
+ // if (nextMode !== modeRef.current) {
+ // setMode(nextMode);
+ // }
+ // }, [contentState.drawingMode, contentState.blurMode]);
- if (nextMode !== modeRef.current) {
- setMode(nextMode);
- }
- }, [contentState.drawingMode, contentState.blurMode]);
+ useEffect(() => {
+ // one-time init
+ if (contentState.drawingMode) setMode("draw");
+ else if (contentState.blurMode) setMode("blur");
+ else setMode("");
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ }, []);
useEffect(() => {
if (mode === "draw") {
@@ -440,7 +448,7 @@ const ToolbarWrap = () => {
if (contentState.openToast) {
contentState.openToast(
chrome.i18n.getMessage("reopenToolbarToast"),
- () => {}
+ () => {},
);
}
diff --git a/src/pages/Editor/Sandbox.jsx b/src/pages/Editor/Sandbox.jsx
index 928f3f0..95b1a14 100644
--- a/src/pages/Editor/Sandbox.jsx
+++ b/src/pages/Editor/Sandbox.jsx
@@ -98,7 +98,7 @@ const Sandbox = () => {
message.audio,
message.duration,
message.volume,
- message.replaceAudio
+ message.replaceAudio,
);
const base64 = await toBase64(blob);
sendMessage({ type: "updated-blob", base64: base64, topLevel: true });
@@ -122,7 +122,7 @@ const Sandbox = () => {
try {
const arrayBuffer = await blobToArrayBuffer(
ffmpegInstance.current,
- message.blob
+ message.blob,
);
sendMessage({ type: "updated-array-buffer", arrayBuffer: arrayBuffer });
} catch (error) {
@@ -151,7 +151,7 @@ const Sandbox = () => {
message.endTime,
message.cut,
message.duration,
- message.encode
+ message.encode,
);
const base64 = await toBase64(blob);
sendMessage({
@@ -167,7 +167,7 @@ const Sandbox = () => {
const blob = await getFrame(
ffmpegInstance.current,
message.blob,
- message.time
+ message.time,
);
sendMessage({ type: "new-frame", frame: blob });
} catch (error) {
@@ -187,7 +187,7 @@ const Sandbox = () => {
message.blob,
message.startTime,
message.endTime,
- message.duration
+ message.duration,
);
const base64 = await toBase64(blob);
sendMessage({
@@ -203,7 +203,7 @@ const Sandbox = () => {
const blob = await reencodeVideo(
ffmpegInstance.current,
message.blob,
- message.duration
+ message.duration,
);
const base64 = await toBase64(blob);
sendMessage({ type: "updated-blob", base64: base64, topLevel: true });
@@ -223,7 +223,7 @@ const Sandbox = () => {
const blob = await toWebM(
ffmpegInstance.current,
message.blob,
- message.duration
+ message.duration,
);
const base64 = await toBase64(blob);
@@ -242,15 +242,9 @@ const Sandbox = () => {
};
useEffect(() => {
- window.addEventListener("message", (event) => {
- onMessage(event.data);
- });
-
- return () => {
- window.removeEventListener("message", (event) => {
- onMessage(event.data);
- });
- };
+ const handler = (event) => onMessage(event.data);
+ window.addEventListener("message", handler);
+ return () => window.removeEventListener("message", handler);
}, []);
return (
diff --git a/src/pages/Sandbox/context/ContentState.jsx b/src/pages/Sandbox/context/ContentState.jsx
index af0ce42..e22f66f 100644
--- a/src/pages/Sandbox/context/ContentState.jsx
+++ b/src/pages/Sandbox/context/ContentState.jsx
@@ -108,7 +108,7 @@ const ContentState = (props) => {
items.sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
const parts = items.map((c) =>
- c.chunk instanceof Blob ? c.chunk : new Blob([c.chunk])
+ c.chunk instanceof Blob ? c.chunk : new Blob([c.chunk]),
);
const first = parts[0];
@@ -155,7 +155,7 @@ const ContentState = (props) => {
const baseTitle = sanitizeFilenameBase(
recordingMeta.title?.trim() ||
getHostnameFromUrl(recordingMeta.url) ||
- fallbackTitle
+ fallbackTitle,
);
const timestamp = formatLocalTimestamp(recordingMeta.startedAt);
setContentState((prevState) => ({
@@ -362,7 +362,7 @@ const ContentState = (props) => {
}
const { recordingDuration } = await chrome.storage.local.get(
- "recordingDuration"
+ "recordingDuration",
);
// Check if token is present
@@ -418,7 +418,7 @@ const ContentState = (props) => {
};
reader.readAsDataURL(fixedWebm);
},
- { logger: false }
+ { logger: false },
);
} else {
const fixedWebm = await fixWebmDurationFallback(blob, {
@@ -509,7 +509,7 @@ const ContentState = (props) => {
chrome.i18n.getMessage("learnMoreDot"),
() => {
chrome.runtime.sendMessage({ type: "memory-limit-help" });
- }
+ },
);
}
});
@@ -538,12 +538,18 @@ const ContentState = (props) => {
...prevState,
chunkIndex: prevState.chunkIndex + 1,
}));
- })
+ }),
);
sendResponse({ status: "ok" });
- } catch (error) {
- console.error("Error processing batch", error);
+ } catch (err) {
+ console.error("Error processing batch", err);
+ try {
+ sendResponse?.({
+ status: "error",
+ error: String(err?.message || err),
+ });
+ } catch {}
}
})();
@@ -575,9 +581,23 @@ const ContentState = (props) => {
// All chunks received, reconstruct video
checkMemory();
reconstructVideo();
- if (sendResponse !== null) {
- sendResponse({ status: "ok" });
- }
+
+ setTimeout(() => {
+ const s = contentStateRef.current;
+ const complete = s?.chunkCount > 0 && s?.chunkIndex >= s?.chunkCount;
+ if (complete && !s?.ready && s?.rawBlob) {
+ setContentState((prev) => ({
+ ...prev,
+ webm: prev.webm || prev.rawBlob,
+ ready: true,
+ noffmpeg: true,
+ isFfmpegRunning: false,
+ }));
+ chrome.runtime.sendMessage({ type: "recording-complete" });
+ }
+ }, 30000);
+
+ if (sendResponse) sendResponse({ status: "ok" });
};
const toBase64 = (blob) => {
@@ -698,7 +718,7 @@ const ContentState = (props) => {
videoChunks.current,
contentState,
contentStateRef.current,
- ]
+ ],
);
useEffect(() => {
@@ -847,6 +867,22 @@ const ContentState = (props) => {
// contentState.loadFFmpeg();
// });
// }
+ } else if (event.data.type === "ffmpeg-error") {
+ console.warn("FFmpeg error:", event.data.error);
+
+ // Fallback: allow playback/download using webm/rawBlob even if conversion fails
+ setContentState((prev) => ({
+ ...prev,
+ noffmpeg: true,
+ ffmpegLoaded: true, // treat as “done trying”
+ isFfmpegRunning: false,
+ processingProgress: 0,
+ ...(prev.rawBlob || prev.webm
+ ? { ready: true, webm: prev.webm || prev.rawBlob }
+ : {}),
+ }));
+
+ chrome.runtime.sendMessage({ type: "recording-complete" });
} else if (event.data.type === "crop-update") {
setContentState((prevContentState) => ({
...prevContentState,
@@ -1119,7 +1155,7 @@ const ContentState = (props) => {
const baseTitle = sanitizeFilenameBase(
currentTitle && currentTitle.trim().length > 0
? currentTitle
- : recordingMeta.title || getHostnameFromUrl(recordingMeta.url)
+ : recordingMeta.title || getHostnameFromUrl(recordingMeta.url),
);
const timestamp = formatLocalTimestamp(recordingMeta.startedAt);
title = `${baseTitle} — ${timestamp}${ext}`;
@@ -1161,7 +1197,7 @@ const ContentState = (props) => {
} else {
resolve(id);
}
- }
+ },
);
});