Skip to content

Free open-source image editor for the browser

7.2 KB
Raw Blame
import { type PointerEvent, useEffect, useRef, useState } from "react";
import { useStore } from "zustand";
import { useDocumentMapping } from "@/components/editor/mapping";
import { useDocument, useScene } from "@/components/editor/session";
import { useViewport } from "@/components/editor/viewport";
import { findLayer, type Gradient, locateLayer } from "@/core/document";
import type { Point } from "@/core/image/frame";
import { useShortcuts } from "@/hooks/use-shortcuts";
import { blurActive } from "@/lib/dom";
import { setLayerMask } from "./edits";
import {
  drawGradient,
  type GradientHandle,
  gradientHandles,
  moveGradient,
} from "./gradient";
import { GradientGuides } from "./gradient-guides";
import { type Nesting, useMaskTool } from "./mask-tool";

type Drag = {
  pointer: number;
  /** The viewport bounds measured once; pointer capture keeps them valid for the drag. */
  box: DOMRect;
  from: Point;
  to: Point;
  mask: Gradient;
  handle: GradientHandle | "new";
  id: string;
  /** Alt while starting a drag subtracts the new gradient from the selected mask. */
  nesting?: Nesting;
};

/** Draws masks of one shape and edits the selected gradient's guides; Enter or Escape leaves. */
export function GradientOverlay({ shape }: { shape: Gradient["kind"] }) {
  const document = useDocument();
  const tool = useMaskTool();
  const camera = useViewport();
  const mapping = useDocumentMapping();
  const selected = useStore(document.selection, (state) => state.layerId);
  const layer = useScene((scene) => {
    const item = findLayer(scene.layers, selected);
    return item?.kind === "mask" ? item : undefined;
  });
  /** Only gradients have guides; other masks keep the deletion shortcuts. */
  const selectedMask = layer?.mask;
  const mask =
    selectedMask?.kind === "linear" || selectedMask?.kind === "radial"
      ? selectedMask
      : undefined;
  const [draft, setDraft] = useState<Gradient | null>(null);
  const dragging = useRef<Drag | null>(null);
  const [dragCursor, setDragCursor] = useState<string>();
  /** Ends any drag, restoring the scene unless it was committed. */
  function reset() {
    if (dragging.current && dragging.current.handle !== "new") {
      document.history.cancel();
    }
    dragging.current = null;
    setDraft(null);
    tool.draft.setState(null);
    setDragCursor(undefined);
  }
  useEffect(
    () => () => {
      if (dragging.current && dragging.current.handle !== "new") {
        document.history.cancel();
      }
      tool.draft.setState(null);
    },
    [document, tool.draft],
  );
  useShortcuts({
    escape: () => (dragging.current ? reset() : tool.edit()),
    enter: () => {
      if (!dragging.current) {
        tool.edit();
      }
    },
  });
  function documentPoint(event: PointerEvent, box: DOMRect) {
    return mapping.toDocument([
      event.clientX - box.left,
      event.clientY - box.top,
    ]);
  }
  function start(event: PointerEvent<HTMLDivElement>) {
    const box = camera.ref.current?.getBoundingClientRect();
    const from = box && documentPoint(event, box);
    if (
      event.button !== 0 ||
      !event.isPrimary ||
      camera.panMode ||
      !box ||
      !from
    ) {
      return;
    }
    const target =
      event.target instanceof Element
        ? event.target
            .closest("[data-gradient-handle]")
            ?.getAttribute("data-gradient-handle")
        : null;
    const handle = gradientHandles.find((handle) => handle === target);
    // Guides win over drawing, unless a chosen nesting is waiting for this shape.
    const drawing = !handle || !mask || tool.pending?.shape === shape;
    if (drawing) {
      const location = locateLayer(document.scene.getState().layers, selected);
      const group =
        location?.parent?.kind === "mask" ? location.parent : location?.layer;
      dragging.current = {
        pointer: event.pointerId,
        box,
        from,
        to: from,
        mask: drawGradient(shape, from, from),
        handle: "new",
        id: selected,
        nesting:
          event.altKey && group?.kind === "mask"
            ? { parentId: group.id, operation: "subtract" }
            : undefined,
      };
      setDraft(dragging.current.mask);
    } else if (mask && handle) {
      document.history.commit();
      document.history.begin();
      dragging.current = {
        pointer: event.pointerId,
        box,
        from,
        to: from,
        mask,
        handle,
        id: selected,
      };
    }
    const cursor =
      event.target instanceof Element
        ? getComputedStyle(event.target).cursor
        : "grab";
    const activeCursor = cursor === "grab" ? "grabbing" : cursor;
    setDragCursor(drawing ? "crosshair" : activeCursor);
    event.preventDefault();
    event.stopPropagation();
    event.currentTarget.setPointerCapture(event.pointerId);
    // Keys after a drag belong to the mask, not to the button that started the tool.
    blurActive();
  }
  function move(event: PointerEvent<HTMLDivElement>) {
    const drag = dragging.current;
    if (!drag || drag.pointer !== event.pointerId) {
      return;
    }
    const point = documentPoint(event, drag.box);
    // Past where input stops the drag keeps its last shape until the pointer returns.
    if (!point) {
      return;
    }
    drag.to = point;
    if (drag.handle === "new") {
      const next = drawGradient(
        drag.mask.kind,
        drag.from,
        point,
        event.shiftKey,
      );
      drag.mask = next;
      setDraft(next);
      tool.draft.setState(next);
    } else {
      setLayerMask(
        document,
        drag.id,
        moveGradient(drag.mask, drag.handle, drag.from, point),
      );
    }
  }
  function finish(event: PointerEvent<HTMLDivElement>) {
    const drag = dragging.current;
    if (!drag || drag.pointer !== event.pointerId) {
      return;
    }
    // Commit the last preview; pointerup must not reinterpret geometry or Shift.
    if (drag.handle === "new") {
      const from = mapping.toScreen(drag.from);
      const to = mapping.toScreen(drag.to);
      if (from && to && Math.hypot(to[0] - from[0], to[1] - from[1]) >= 3) {
        tool.create(drag.mask, drag.nesting);
      }
    } else {
      document.history.commit();
    }
    reset();
    event.currentTarget.releasePointerCapture(event.pointerId);
  }
  const visible = draft ?? mask;
  // The empty canvas draws, so it shows a crosshair; guides keep their own cursors until a drag starts.
  const cursor = dragCursor ?? "crosshair";
  return (
    <div
      role="application"
      aria-label="Gradient mask canvas"
      className="absolute inset-0 touch-none data-[cursor=true]:[&_*]:cursor-[inherit]! data-[pan=true]:pointer-events-none"
      data-cursor={!!dragCursor}
      data-pan={camera.panMode}
      style={{ cursor }}
      onDoubleClick={(event) => event.stopPropagation()}
      onPointerDown={start}
      onPointerMove={move}
      onPointerUp={finish}
      onPointerCancel={reset}
      onLostPointerCapture={() => {
        if (dragging.current) {
          reset();
        }
      }}
    >
      {visible && !camera.panMode && (
        <GradientGuides
          mask={visible}
          mapping={mapping}
          extent={Math.hypot(...camera.viewport)}
        />
      )}
    </div>
  );
}