@witchcraft/layout
    Preparing search index...

    Function useFrames

    • Parameters

      • win: Ref<BaseLayoutWindow>
      • showDragging: Ref<boolean>

        Whether to show merged the moved frames while dragging.

      • handler: {
            eventHandler: (
                e: KeyboardEvent,
                state: DragState,
                forceRecalculateEdges: () => void,
            ) => void;
            onDragApply: (
                state: DragState,
                forceRecalculateEdges: () => void,
            ) => boolean;
            onDragChange: DragChangeHandler;
        }
        • eventHandler: (e: KeyboardEvent, state: DragState, forceRecalculateEdges: () => void) => void
        • onDragApply: (state: DragState, forceRecalculateEdges: () => void) => boolean

          Called when drag will be applied. If dragEnd was called with apply false, it will not be called. Return false to not apply the regular drag end changes (i.e. return false to reset to the position before dragging).

        • onDragChange: DragChangeHandler

          Called when the drag coordinates change (during any event). Should return true to allow the edges to be moved, or false to prevent it.

          Can be used to save some context/info to later apply safely during onDragApply.

      Returns {
          cancel: () => void;
          dragDirections: Ref<
              {
                  horizontal: undefined
                  | "up"
                  | "down"
                  | "left"
                  | "right";
                  vertical: undefined | "up" | "down" | "left" | "right";
              },
              | Record<
                  "horizontal"
                  | "vertical",
                  undefined | "up" | "down" | "left" | "right",
              >
              | {
                  horizontal: undefined | "up" | "down" | "left" | "right";
                  vertical: undefined | "up" | "down" | "left" | "right";
              },
          >;
          dragEnd: (
              e?: PointerEvent,
              __namedParameters?: { apply?: boolean },
          ) => void;
          draggingEdges: Ref<
              { endX: number; endY: number; startX: number; startY: number }[],

                  | { endX: number; endY: number; startX: number; startY: number }[]
                  | { endX: number; endY: number; startX: number; startY: number }[],
          >;
          draggingIntersection: Ref<
              | undefined
              | {
                  count: number;
                  isWindowEdge: boolean;
                  point: { x: number; y: number };
                  sharedEdges: {
                      horizontal: {
                          endX: number;
                          endY: number;
                          startX: number;
                          startY: number;
                      }[];
                      vertical: { endX: number; endY: number; startX: number; startY: number }[];
                  };
                  sharesEdge: boolean;
              },
              | undefined
              | IntersectionEntry
              | {
                  count: number;
                  isWindowEdge: boolean;
                  point: { x: number; y: number };
                  sharedEdges: {
                      horizontal: {
                          endX: number;
                          endY: number;
                          startX: number;
                          startY: number;
                      }[];
                      vertical: { endX: number; endY: number; startX: number; startY: number }[];
                  };
                  sharesEdge: boolean;
              },
          >;
          dragHoveredFrame: ComputedRef<undefined | LayoutFrame>;
          dragPoint: Ref<
              undefined
              | { x: number; y: number },
              undefined | { x: number; y: number },
          >;
          dragStart: (
              e: PointerEvent,
              __namedParameters: {
                  edge?: { endX: number; endY: number; startX: number; startY: number };
                  intersection?: IntersectionEntry;
              },
          ) => void;
          forceRecalculateEdges: () => void;
          frames: ComputedRef<LayoutFrames>;
          intersections: ComputedRef<IntersectionEntry[]>;
          isDragging: Ref<boolean, boolean>;
          isDraggingFromWindowEdge: Ref<boolean, boolean>;
          state: ComputedRef<
              {
                  dragDirections: {
                      horizontal: undefined
                      | "up"
                      | "down"
                      | "left"
                      | "right";
                      vertical: undefined | "up" | "down" | "left" | "right";
                  };
                  draggingEdges: {
                      endX: number;
                      endY: number;
                      startX: number;
                      startY: number;
                  }[];
                  draggingIntersection: | undefined
                  | {
                      count: number;
                      isWindowEdge: boolean;
                      point: { x: number; y: number };
                      sharedEdges: {
                          horizontal: {
                              endX: number;
                              endY: number;
                              startX: number;
                              startY: number;
                          }[];
                          vertical: {
                              endX: number;
                              endY: number;
                              startX: number;
                              startY: number;
                          }[];
                      };
                      sharesEdge: boolean;
                  };
                  dragHoveredFrame: undefined
                  | LayoutFrame;
                  dragPoint: undefined | { x: number; y: number };
                  frames: LayoutFrames;
                  intersections: IntersectionEntry[];
                  isDragging: boolean;
                  isDraggingFromWindowEdge: boolean;
                  touchingFrames: Record<string, LayoutFrame>[];
                  touchingFramesArrays: LayoutFrame[][];
                  visualEdges: {
                      endX: number;
                      endY: number;
                      startX: number;
                      startY: number;
                  }[];
                  win: BaseLayoutWindow;
              },
          >;
          touchingFrames: Ref<
              Record<string, LayoutFrame>[],
              Record<string, LayoutFrame>[],
          >;
          touchingFramesArrays: ComputedRef<LayoutFrame[][]>;
          visualEdges: Ref<
              { endX: number; endY: number; startX: number; startY: number }[],

                  | { endX: number; endY: number; startX: number; startY: number }[]
                  | { endX: number; endY: number; startX: number; startY: number }[],
          >;
      }

    Settings

    Member Visibility