Free open-source image editor for the browser
import { type PointerEvent, useEffect, useRef, useState } from "react";
import { useGpu } from "vgpu-react";
import { useStore } from "zustand";
import { CanvasHint } from "@/components/editor/canvas-hint";
import { useDocumentMapping } from "@/components/editor/mapping";
import { useRenderer } from "@/components/editor/pipeline";
import { useDocument, useScene } from "@/components/editor/session";
import { useViewport } from "@/components/editor/viewport";
import { eyedropperCursor } from "@/components/icons/eyedropper-cursor";
import { findLayer, locateLayer } from "@/core/document";
import { useDisposable } from "@/hooks/use-disposable";
import { useShortcuts } from "@/hooks/use-shortcuts";
import { createColorSampler } from "./color-sample";
import { setLayerMask } from "./edits";
import { useMaskTool } from "./mask-tool";
type Drag = {
pointer: number;
/** The viewport bounds measured once; pointer capture keeps them valid for the drag. */
box: DOMRect;
target: string;
opened: boolean;
/** Whether the drag was cancelled, so colors still to land change nothing. */
cancelled: boolean;
/** The latest color to land, which the drag waits for before it ends. */
landed: Promise<void>;
};
/**
* Picks colors from the photo for the selected color range; a drag is one edit.
* Colors come from the image below the range's mask group, the one it selects from, so its own edit
* never feeds back. Enter or Escape leaves.
*/
export function RangePicker() {
const gpu = useGpu();
const document = useDocument();
const renderer = useRenderer();
const camera = useViewport();
const mapping = useDocumentMapping();
const tool = useMaskTool();
const sampler = useDisposable(() => createColorSampler(gpu), [gpu]);
const selected = useStore(document.selection, (state) => state.layerId);
const editing = useScene((scene) => {
const layer = findLayer(scene.layers, selected);
return layer?.kind === "mask" && layer.mask.kind === "color-range";
});
const group = useScene((scene) => {
const parent = locateLayer(scene.layers, selected)?.parent;
return parent?.kind === "mask" ? parent.id : selected;
});
const size = document.resources.get(
useScene((scene) => scene.layers[0].source),
).image.size;
const [error, setError] = useState("");
const live = useRef(true);
useEffect(() => {
if (!editing) {
tool.edit();
return;
}
document.preview.setState({ rangeSource: group });
return () => document.preview.setState({ rangeSource: undefined });
}, [document, editing, group, tool.edit]);
const drag = useRef<Drag | null>(null);
const inFlight = useRef(new Set<Drag>());
/** The previous drag's end, which a new drag's colors wait for so the two edits never overlap. */
const ended = useRef<Promise<void>>(Promise.resolve());
function cancelDrag(current: Drag) {
current.cancelled = true;
if (current.opened) {
current.opened = false;
document.history.cancel();
}
}
/** Gives the drag's color range a color, while it is one. */
function recolor(id: string, color: string) {
const layer = findLayer(document.scene.getState().layers, id);
if (layer?.kind === "mask" && layer.mask.kind === "color-range") {
setLayerMask(document, id, { ...layer.mask, color });
}
}
/** Picks the color under the pointer and waits for the previous pick to land. */
function pick(current: Drag, event: PointerEvent) {
const at = mapping.toDocument([
event.clientX - current.box.left,
event.clientY - current.box.top,
]);
if (!at) {
return;
}
const [x, y] = at;
const image = () => renderer.rangeSource(group);
const color = sampler.sample(image, [x / size[0], y / size[1]]);
current.landed = Promise.all([current.landed, color])
.then(([, color]) => {
if (!color || current.cancelled || document.closed) {
return;
}
if (document.selection.getState().layerId !== current.target) {
cancelDrag(current);
return;
}
if (!current.opened) {
if (document.history.status.getState().editing) {
current.cancelled = true;
if (live.current) {
setError("Finish the current edit before picking a color.");
}
return;
}
current.opened = document.history.begin();
}
recolor(current.target, color);
})
.catch(() => {
cancelDrag(current);
if (live.current) {
setError("Couldn't pick a color. Try again.");
}
});
}
function end(cancel: boolean) {
const current = drag.current;
if (!current) {
return;
}
drag.current = null;
if (cancel) {
cancelDrag(current);
}
ended.current = current.landed.then(() => {
inFlight.current.delete(current);
if (current.opened) {
current.opened = false;
document.history.commit();
}
});
}
useEffect(() => {
live.current = true;
const selection = document.selection.subscribe(({ layerId }) => {
for (const current of inFlight.current) {
if (current.target !== layerId) {
cancelDrag(current);
}
}
});
const history = document.history.status.subscribe(({ editing }) => {
if (!editing) {
for (const current of inFlight.current) {
if (current.opened) {
current.opened = false;
current.cancelled = true;
}
}
}
});
return () => {
live.current = false;
selection();
history();
end(true);
for (const current of inFlight.current) {
cancelDrag(current);
}
};
}, [document]);
useShortcuts({
escape: () => (drag.current ? end(true) : tool.edit()),
enter: () => {
if (!drag.current) {
tool.edit();
}
},
});
function start(event: PointerEvent<HTMLDivElement>) {
const box = camera.ref.current?.getBoundingClientRect();
if (
event.button !== 0 ||
!event.isPrimary ||
!box ||
!editing ||
drag.current
) {
return;
}
event.stopPropagation();
event.currentTarget.setPointerCapture(event.pointerId);
const current: Drag = {
pointer: event.pointerId,
box,
target: selected,
opened: false,
cancelled: false,
landed: ended.current,
};
drag.current = current;
inFlight.current.add(current);
setError("");
pick(current, event);
}
function move(event: PointerEvent<HTMLDivElement>) {
const current = drag.current;
if (current?.pointer === event.pointerId) {
pick(current, event);
}
}
function finish(event: PointerEvent<HTMLDivElement>) {
if (drag.current?.pointer !== event.pointerId) {
return;
}
event.currentTarget.releasePointerCapture(event.pointerId);
end(false);
}
return (
<div
role="application"
aria-label="Color range canvas"
className="absolute inset-0 touch-none data-[pan=true]:pointer-events-none"
style={{ cursor: eyedropperCursor }}
data-pan={camera.panMode}
onDoubleClick={(event) => event.stopPropagation()}
onPointerDown={start}
onPointerMove={move}
onPointerUp={finish}
onPointerCancel={(event) => {
if (drag.current?.pointer === event.pointerId) {
end(true);
}
}}
onLostPointerCapture={(event) => {
if (drag.current?.pointer === event.pointerId) {
end(false);
}
}}
>
<CanvasHint>
{error || "Click or drag over the photo to pick the color to select"}
</CanvasHint>
</div>
);
}