@odoo/o-spreadsheet 14.0.0 → 14.0.1

package/src/plugins/clipboard.ts

@@ -0,0 +1,461 @@
+import { BasePlugin } from "../base_plugin";
+import { clip, toXC } from "../helpers/index";
+import { Mode } from "../model";
+import { _lt } from "../translation";
+import {
+  CancelledReason,
+  Cell,
+  Command,
+  CommandResult,
+  GridRenderingContext,
+  LAYERS,
+  Zone,
+} from "../types/index";
+
+interface ClipboardCell {
+  cell: Cell | null;
+  col: number;
+  row: number;
+}
+
+/**
+ * Clipboard Plugin
+ *
+ * This clipboard manages all cut/copy/paste interactions internal to the
+ * application, and with the OS clipboard as well.
+ */
+export class ClipboardPlugin extends BasePlugin {
+  static layers = [LAYERS.Clipboard];
+  static getters = ["getClipboardContent", "isPaintingFormat", "getPasteZones"];
+  static modes: Mode[] = ["normal", "readonly"];
+
+  private status: "empty" | "visible" | "invisible" = "empty";
+  private shouldCut?: boolean;
+  private zones: Zone[] = [];
+  private cells?: ClipboardCell[][];
+  private originSheet: string = this.workbook.activeSheet.id;
+  private _isPaintingFormat: boolean = false;
+  private pasteOnlyValue: boolean = false;
+  private pasteOnlyFormat: boolean = false;
+
+  // ---------------------------------------------------------------------------
+  // Command Handling
+  // ---------------------------------------------------------------------------
+
+  allowDispatch(cmd: Command): CommandResult {
+    if (cmd.type === "PASTE") {
+      return this.isPasteAllowed(cmd.target);
+    }
+    return {
+      status: "SUCCESS",
+    };
+  }
+
+  handle(cmd: Command) {
+    switch (cmd.type) {
+      case "COPY":
+        this.cutOrCopy(cmd.target, false);
+        break;
+      case "CUT":
+        this.cutOrCopy(cmd.target, true);
+        break;
+      case "PASTE":
+        this.pasteOnlyValue = "onlyValue" in cmd && !!cmd.onlyValue;
+        const onlyFormat = "onlyFormat" in cmd ? !!cmd.onlyFormat : this._isPaintingFormat;
+        this._isPaintingFormat = false;
+        this.pasteOnlyFormat = !this.pasteOnlyValue && onlyFormat;
+        if (cmd.interactive) {
+          this.interactivePaste(cmd.target);
+        } else {
+          this.pasteFromModel(cmd.target);
+        }
+        break;
+      case "PASTE_CELL":
+        this.pasteCell(cmd.origin, cmd.col, cmd.row, cmd.onlyValue, cmd.onlyFormat);
+        break;
+      case "PASTE_FROM_OS_CLIPBOARD":
+        this.pasteFromClipboard(cmd.target, cmd.text);
+        break;
+      case "ACTIVATE_PAINT_FORMAT":
+        this._isPaintingFormat = true;
+        this.cutOrCopy(cmd.target, false);
+        break;
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Getters
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Format the current clipboard to a string suitable for being pasted in other
+   * programs.
+   *
+   * - add a tab character between each concecutive cells
+   * - add a newline character between each line
+   *
+   * Note that it returns \t if the clipboard is empty. This is necessary for the
+   * clipboard copy event to add it as data, otherwise an empty string is not
+   * considered as a copy content.
+   */
+  getClipboardContent(): string {
+    if (!this.cells) {
+      return "\t";
+    }
+    return (
+      this.cells
+        .map((cells) => {
+          return cells.map((c) => (c.cell ? this.getters.getCellText(c.cell) : "")).join("\t");
+        })
+        .join("\n") || "\t"
+    );
+  }
+
+  getPasteZones(target: Zone[]): Zone[] {
+    if (!this.cells) {
+      return target;
+    }
+    const height = this.cells.length;
+    const width = this.cells[0].length;
+    const selection = target[target.length - 1];
+    const pasteZones: Zone[] = [];
+    let col = selection.left;
+    let row = selection.top;
+    const repX = Math.max(1, Math.floor((selection.right + 1 - selection.left) / width));
+    const repY = Math.max(1, Math.floor((selection.bottom + 1 - selection.top) / height));
+    for (let x = 1; x <= repX; x++) {
+      for (let y = 1; y <= repY; y++) {
+        pasteZones.push({
+          left: col,
+          top: row,
+          right: col - 1 + x * width,
+          bottom: row - 1 + y * height,
+        });
+      }
+    }
+    return pasteZones;
+  }
+
+  isPaintingFormat(): boolean {
+    return this._isPaintingFormat;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Private methods
+  // ---------------------------------------------------------------------------
+
+  private cutOrCopy(zones: Zone[], cut: boolean) {
+    const tops = new Set(zones.map((z) => z.top));
+    const bottoms = new Set(zones.map((z) => z.bottom));
+    const areZonesCompatible = tops.size === 1 && bottoms.size === 1;
+    let clippedZones = areZonesCompatible ? zones : [zones[zones.length - 1]];
+    clippedZones = clippedZones.map((z) => Object.assign({}, z));
+
+    const cells: ClipboardCell[][] = [];
+    let { top, bottom } = clippedZones[0];
+    for (let r = top; r <= bottom; r++) {
+      const row: ClipboardCell[] = [];
+      cells.push(row);
+      for (let zone of clippedZones) {
+        let { left, right } = zone;
+        for (let c = left; c <= right; c++) {
+          const cell = this.getters.getCell(c, r);
+          row.push({
+            cell: cell ? Object.assign({}, cell) : null,
+            col: c,
+            row: r,
+          });
+        }
+      }
+    }
+    this.status = "visible";
+    this.shouldCut = cut;
+    this.zones = clippedZones;
+    this.cells = cells;
+    this.originSheet = this.workbook.activeSheet.id;
+  }
+
+  private pasteFromClipboard(target: Zone[], content: string) {
+    this.status = "invisible";
+    const values = content
+      .replace(/\r/g, "")
+      .split("\n")
+      .map((vals) => vals.split("\t"));
+    const { left: activeCol, top: activeRow } = target[0];
+    const width = Math.max.apply(
+      Math,
+      values.map((a) => a.length)
+    );
+    const height = values.length;
+    this.addMissingDimensions(width, height, activeCol, activeRow);
+    for (let i = 0; i < values.length; i++) {
+      for (let j = 0; j < values[i].length; j++) {
+        const xc = toXC(activeCol + j, activeRow + i);
+        this.dispatch("SET_VALUE", { xc, text: values[i][j] });
+      }
+    }
+    this.dispatch("SET_SELECTION", {
+      anchor: [activeCol, activeRow],
+      zones: [
+        {
+          left: activeCol,
+          top: activeRow,
+          right: activeCol + width - 1,
+          bottom: activeRow + height - 1,
+        },
+      ],
+    });
+  }
+
+  private isPasteAllowed(target: Zone[]): CommandResult {
+    const { zones, cells, status } = this;
+    // cannot paste if we have a clipped zone larger than a cell and multiple
+    // zones selected
+    if (!zones || !cells || status === "empty") {
+      return { status: "CANCELLED", reason: CancelledReason.EmptyClipboard };
+    } else if (target.length > 1 && (cells.length > 1 || cells[0].length > 1)) {
+      return { status: "CANCELLED", reason: CancelledReason.WrongPasteSelection };
+    }
+    return { status: "SUCCESS" };
+  }
+
+  private pasteFromModel(target: Zone[]) {
+    const { cells, shouldCut } = this;
+    if (!cells) {
+      return;
+    }
+    this.status = shouldCut ? "empty" : "invisible";
+    if (shouldCut) {
+      this.clearCutZone();
+    }
+    const height = cells.length;
+    const width = cells[0].length;
+    if (target.length > 1) {
+      for (let zone of target) {
+        for (let i = zone.left; i <= zone.right; i++) {
+          for (let j = zone.top; j <= zone.bottom; j++) {
+            this.pasteZone(width, height, i, j);
+          }
+        }
+      }
+      return;
+    }
+    const selection = target[target.length - 1];
+    let col = selection.left;
+    let row = selection.top;
+    const repX = Math.max(1, Math.floor((selection.right + 1 - selection.left) / width));
+    const repY = Math.max(1, Math.floor((selection.bottom + 1 - selection.top) / height));
+    for (let x = 0; x < repX; x++) {
+      for (let y = 0; y < repY; y++) {
+        this.pasteZone(width, height, col + x * width, row + y * height);
+      }
+    }
+
+    if (height > 1 || width > 1) {
+      const newSelection = {
+        left: col,
+        top: row,
+        right: col + repX * width - 1,
+        bottom: row + repY * height - 1,
+      };
+      const [anchorCol, anchorRow] = this.getters.getSelection().anchor;
+      const newCol = clip(anchorCol, col, col + repX * width - 1);
+      const newRow = clip(anchorRow, row, row + repY * height - 1);
+      this.dispatch("SET_SELECTION", {
+        anchor: [newCol, newRow],
+        zones: [newSelection],
+      });
+    }
+  }
+
+  private clearCutZone() {
+    for (let row of this.cells!) {
+      for (let cell of row) {
+        if (cell) {
+          this.dispatch("CLEAR_CELL", {
+            sheet: this.originSheet,
+            col: cell.col,
+            row: cell.row,
+          });
+        }
+      }
+    }
+  }
+
+  private pasteZone(width: number, height: number, col: number, row: number) {
+    // first, add missing cols/rows if needed
+    this.addMissingDimensions(width, height, col, row);
+    // then, perform the actual paste operation
+    for (let r = 0; r < height; r++) {
+      const rowCells = this.cells![r];
+      for (let c = 0; c < width; c++) {
+        const originCell = rowCells[c];
+        this.dispatch("PASTE_CELL", {
+          origin: originCell.cell,
+          originCol: originCell.col,
+          originRow: originCell.row,
+          col: col + c,
+          row: row + r,
+          sheet: this.originSheet,
+          cut: this.shouldCut,
+          onlyValue: this.pasteOnlyValue,
+          onlyFormat: this.pasteOnlyFormat,
+        });
+      }
+    }
+  }
+
+  private addMissingDimensions(width, height, col, row) {
+    const { cols, rows } = this.workbook.activeSheet;
+    const missingRows = height + row - rows.length;
+    if (missingRows > 0) {
+      this.dispatch("ADD_ROWS", {
+        row: rows.length - 1,
+        sheet: this.workbook.activeSheet.id,
+        quantity: missingRows,
+        position: "after",
+      });
+    }
+    const missingCols = width + col - cols.length;
+    if (missingCols > 0) {
+      this.dispatch("ADD_COLUMNS", {
+        column: cols.length - 1,
+        sheet: this.workbook.activeSheet.id,
+        quantity: missingCols,
+        position: "after",
+      });
+    }
+  }
+
+  pasteCell(
+    origin: Cell | null,
+    col: number,
+    row: number,
+    onlyValue: boolean,
+    onlyFormat: boolean
+  ) {
+    const targetCell = this.getters.getCell(col, row);
+    if (origin) {
+      let style = origin.style;
+      let border = origin.border;
+      let format = origin.format;
+      let content: string | undefined = origin.content || "";
+
+      if (onlyValue) {
+        style = targetCell ? targetCell.style : undefined;
+        border = targetCell ? targetCell.border : undefined;
+        format = targetCell ? targetCell.format : undefined;
+
+        if (targetCell) {
+          if (targetCell.type === "date") {
+            format = targetCell.value.format;
+          }
+        }
+        if (origin.type === "formula" || origin.type === "date") {
+          content = this.valueToContent(origin.value);
+        }
+      } else if (onlyFormat) {
+        content = targetCell ? targetCell.content : "";
+      } else if (origin.type === "formula") {
+        const offsetX = col - origin.col;
+        const offsetY = row - origin.row;
+        content = this.getters.applyOffset(content, offsetX, offsetY);
+      }
+
+      let newCell = {
+        style: style,
+        border: border,
+        format: format,
+        sheet: this.workbook.activeSheet.id,
+        col: col,
+        row: row,
+        content: content,
+      };
+
+      this.dispatch("UPDATE_CELL", newCell);
+    }
+    if (!origin && targetCell) {
+      if (onlyValue) {
+        if (targetCell.content) {
+          //this.history.updateCell(targetCell, "content", undefined);
+          this.history.updateCell(targetCell, "content", "");
+          this.history.updateCell(targetCell, "value", "");
+        }
+      } else if (onlyFormat) {
+        if (targetCell.style) {
+          this.history.updateCell(targetCell, "style", undefined);
+        }
+        if (targetCell.border) {
+          this.history.updateCell(targetCell, "border", undefined);
+        }
+        if (targetCell.format) {
+          this.history.updateCell(targetCell, "format", undefined);
+        }
+      } else {
+        this.dispatch("CLEAR_CELL", {
+          sheet: this.workbook.activeSheet.id,
+          col: col,
+          row: row,
+        });
+      }
+    }
+  }
+
+  private valueToContent(cellValue: any): string {
+    switch (typeof cellValue) {
+      case "number":
+        return cellValue.toString();
+      case "string":
+        return cellValue;
+      case "boolean":
+        return cellValue ? "TRUE" : "FALSE";
+      case "object":
+        return cellValue.value.toString();
+      default:
+        return "";
+    }
+  }
+
+  interactivePaste(target: Zone[]) {
+    const result = this.dispatch("PASTE", { target, onlyFormat: false });
+
+    if (result.status === "CANCELLED") {
+      if (result.reason === CancelledReason.WrongPasteSelection) {
+        this.ui.notifyUser(_lt("This operation is not allowed with multiple selections."));
+      }
+      if (result.reason === CancelledReason.WillRemoveExistingMerge) {
+        this.ui.askConfirmation(
+          _lt("Pasting here will remove existing merge(s). Paste anyway?"),
+          () => this.dispatch("PASTE", { target, onlyFormat: false, force: true })
+        );
+      }
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Grid rendering
+  // ---------------------------------------------------------------------------
+
+  drawGrid(renderingContext: GridRenderingContext) {
+    const { viewport, ctx, thinLineWidth } = renderingContext;
+    const zones = this.zones;
+    if (
+      this.status !== "visible" ||
+      !zones.length ||
+      this.originSheet !== this.getters.getActiveSheet()
+    ) {
+      return;
+    }
+    ctx.save();
+    ctx.setLineDash([8, 5]);
+    ctx.strokeStyle = "#3266ca";
+    ctx.lineWidth = 3.3 * thinLineWidth;
+    for (const zone of zones) {
+      const [x, y, width, height] = this.getters.getRect(zone, viewport);
+      if (width > 0 && height > 0) {
+        ctx.strokeRect(x, y, width, height);
+      }
+    }
+    ctx.restore();
+  }
+}