layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/75-tables.js

@@ -0,0 +1,676 @@
+/* Wunschliste J Nr. 1 (Sitzung 8) – Tabellen: create_table, set_table_cells, set_table_style, get_table. */
+
+var IDC_TABLE_CHAR = '';
+
+function idcTableStyleByName(doc, name) {
+  var style = null, all, i;
+  try {
+    style = doc.tableStyles.itemByName(name);
+    if (style && style.isValid === true) { return style; }
+  } catch (e0) { /* weiter */ }
+  try {
+    all = doc.allTableStyles;
+    for (i = 0; i < all.length; i++) { if (String(all[i].name) === String(name)) { return all[i]; } }
+  } catch (e1) { /* weiter */ }
+  return null;
+}
+
+function idcCellStyleByName(doc, name) {
+  var style = null, all, i;
+  try {
+    style = doc.cellStyles.itemByName(name);
+    if (style && style.isValid === true) { return style; }
+  } catch (e0) { /* weiter */ }
+  try {
+    all = doc.allCellStyles;
+    for (i = 0; i < all.length; i++) { if (String(all[i].name) === String(name)) { return all[i]; } }
+  } catch (e1) { /* weiter */ }
+  return null;
+}
+
+function idcStyleNames(list) {
+  var out = [], i;
+  try {
+    for (i = 0; i < list.length; i++) { out.push(String(list[i].name)); }
+  } catch (e) { /* leer */ }
+  return out;
+}
+
+function idcTableStyleArg(doc, name, field) {
+  var style;
+  if (typeof name !== 'string' || name === '') {
+    IDC.fail('invalid_argument', field + ' must be a non-empty string.', { field: field, value: name });
+  }
+  style = idcTableStyleByName(doc, name);
+  if (style === null) {
+    IDC.fail('not_found', 'No table style named "' + name + '" in this document.',
+      { field: field, table_style: name, available: idcStyleNames(doc.allTableStyles) });
+  }
+  return style;
+}
+
+function idcCellStyleArg(doc, name, field) {
+  var style;
+  if (typeof name !== 'string' || name === '') {
+    IDC.fail('invalid_argument', field + ' must be a non-empty string.', { field: field, value: name });
+  }
+  style = idcCellStyleByName(doc, name);
+  if (style === null) {
+    IDC.fail('not_found', 'No cell style named "' + name + '" in this document.',
+      { field: field, cell_style: name, available: idcStyleNames(doc.allCellStyles) });
+  }
+  return style;
+}
+
+function idcCountArg(value, field, min, max, fallback) {
+  if (value === undefined || value === null) { return fallback; }
+  if (typeof value !== 'number' || Math.floor(value) !== value || value < min || value > max) {
+    IDC.fail('invalid_argument', field + ' must be a whole number from ' + min + ' to ' + max + '.', { field: field, value: value });
+  }
+  return value;
+}
+
+/* Zellmatrix pruefen: Liste von Zeilen, jede Zeile eine Liste von Texten (Zahlen erlaubt; null = Zelle nicht anfassen). */
+function idcCellsArg(value, field) {
+  var rows = [], r, c, row, out, cell;
+  if (!IDC.isArray(value) || value.length === 0) {
+    IDC.fail('invalid_argument', field + ' must be a non-empty list of rows (each row a list of cell texts).', { field: field });
+  }
+  if (value.length > 1000) {
+    IDC.fail('invalid_argument', field + ' may hold at most 1000 rows.', { field: field, rows: value.length });
+  }
+  for (r = 0; r < value.length; r++) {
+    row = value[r];
+    if (!IDC.isArray(row)) {
+      IDC.fail('invalid_argument', field + ' row ' + r + ' is not a list.', { field: field, row: r });
+    }
+    if (row.length > 100) {
+      IDC.fail('invalid_argument', field + ' row ' + r + ' has more than 100 cells.', { field: field, row: r });
+    }
+    out = [];
+    for (c = 0; c < row.length; c++) {
+      cell = row[c];
+      if (cell === null || cell === undefined) { out.push(null); continue; }
+      if (typeof cell !== 'string' && typeof cell !== 'number') {
+        IDC.fail('invalid_argument', field + ' cell ' + r + '/' + c + ' must be text or a number.', { field: field, row: r, column: c });
+      }
+      out.push(idcNormaliseText(String(cell)));
+    }
+    rows.push(out);
+  }
+  return rows;
+}
+
+function idcMaxRowLength(rows) {
+  var max = 0, r;
+  for (r = 0; r < rows.length; r++) { if (rows[r].length > max) { max = rows[r].length; } }
+  return max;
+}
+
+/* Zelle an Zeile/Spalte (Zaehlung ueber alle Zeilen: Kopf, Koerper, Fuss). Zusammengefuegte: die fuehrende Zelle, sonst null. */
+function idcCellAt(table, row, column) {
+  var cell = null, cells, i, name, parts;
+  try {
+    cell = table.cells.itemByName(column + ':' + row);
+    if (cell && cell.isValid === true) { return cell; }
+  } catch (e0) { cell = null; }
+  try {
+    cells = table.rows.item(row).cells;
+    for (i = 0; i < cells.length; i++) {
+      cell = cells.item(i);
+      name = String(cell.name);
+      parts = name.split(':');
+      if (Number(parts[0]) === column) { return cell; }
+    }
+  } catch (e1) { /* null */ }
+  return null;
+}
+
+function idcRowType(table, rowIndex) {
+  var header = 0, body = 0;
+  try { header = Number(table.headerRowCount); } catch (e0) { header = 0; }
+  try { body = Number(table.bodyRowCount); } catch (e1) { body = 0; }
+  if (rowIndex < header) { return 'header'; }
+  if (rowIndex < header + body) { return 'body'; }
+  return 'footer';
+}
+
+function idcTableCounts(table) {
+  var out = { rows: null, body_rows: null, header_rows: null, footer_rows: null, columns: null };
+  try { out.body_rows = Number(table.bodyRowCount); } catch (e0) { /* null */ }
+  try { out.header_rows = Number(table.headerRowCount); } catch (e1) { /* null */ }
+  try { out.footer_rows = Number(table.footerRowCount); } catch (e2) { /* null */ }
+  try { out.columns = Number(table.columnCount); } catch (e3) { /* null */ }
+  try { out.rows = Number(table.rows.length); } catch (e4) { out.rows = null; }
+  if (out.rows === null && out.body_rows !== null) { out.rows = out.body_rows + (out.header_rows || 0) + (out.footer_rows || 0); }
+  return out;
+}
+
+function idcColumnWidths(table) {
+  var out = [], i;
+  try {
+    for (i = 0; i < table.columns.length; i++) { out.push(IDC.round(Number(table.columns.item(i).width), 3)); }
+  } catch (e) { /* leer */ }
+  return out;
+}
+
+function idcRowHeights(table) {
+  var out = [], i;
+  try {
+    for (i = 0; i < table.rows.length; i++) { out.push(IDC.round(Number(table.rows.item(i).height), 3)); }
+  } catch (e) { /* leer */ }
+  return out;
+}
+
+function idcTableStyleName(table) {
+  try { return String(table.appliedTableStyle.name); } catch (e) { return null; }
+}
+
+function idcTableStoryOffset(table) {
+  try { return Number(table.storyOffset.index); } catch (e) { return null; }
+}
+
+function idcTableFrameId(table) {
+  var frames;
+  try {
+    frames = table.storyOffset.parentTextFrames;
+    if (frames && frames.length > 0) { return Number(frames[0].id); }
+  } catch (e) { /* null */ }
+  return null;
+}
+
+function idcDescribeTable(table, story, index, count) {
+  var counts = idcTableCounts(table);
+  var out = {
+    table_id: null,
+    table_index: index,
+    table_count: count,
+    story_id: null,
+    story_offset_index: idcTableStoryOffset(table),
+    frame_id: idcTableFrameId(table),
+    rows: counts.rows,
+    body_rows: counts.body_rows,
+    header_rows: counts.header_rows,
+    footer_rows: counts.footer_rows,
+    columns: counts.columns,
+    table_style: idcTableStyleName(table),
+    width_mm: null,
+    height_mm: null,
+    column_widths_mm: idcColumnWidths(table)
+  };
+  try { out.table_id = Number(table.id); } catch (e0) { /* null */ }
+  try { out.story_id = Number(story.id); } catch (e1) { /* null */ }
+  try { out.width_mm = IDC.round(Number(table.width), 3); } catch (e2) { /* null */ }
+  try { out.height_mm = IDC.round(Number(table.height), 3); } catch (e3) { /* null */ }
+  return out;
+}
+
+/* Tabelle ueber frame_id (ein Rahmen der Story) und table_index (Vorgabe 0). */
+function idcTableArg(doc, args) {
+  var found = idcTextFrameArg(doc, args, 'frame_id');
+  var story = idcStoryOf(found.item);
+  var index = idcCountArg(args.table_index, 'table_index', 0, 10000, 0);
+  var count = 0, table = null;
+  try { count = Number(story.tables.length); } catch (e0) { count = 0; }
+  if (count === 0) {
+    IDC.fail('not_found', 'The story of frame ' + args.frame_id + ' has no table; create one with create_table.',
+      { frame_id: args.frame_id, table_count: 0 });
+  }
+  if (index >= count) {
+    IDC.fail('not_found', 'The story of frame ' + args.frame_id + ' has ' + count + ' table(s); table_index ' + index + ' does not exist.',
+      { frame_id: args.frame_id, table_index: index, table_count: count });
+  }
+  try { table = story.tables.item(index); } catch (e1) { table = null; }
+  if (table === null || table === undefined) {
+    IDC.fail('not_found', 'Table ' + index + ' could not be read.', { frame_id: args.frame_id, table_index: index });
+  }
+  return { frame: found.item, story: story, table: table, index: index, count: count };
+}
+
+/* Zellen aus einer Matrix schreiben; liefert Zaehler und Zellen mit Uebersatz. */
+function idcWriteCells(ctx, doc, table, rows, startRow, startColumn, paragraphStyle, cellStyle, grow) {
+  var counts = idcTableCounts(table);
+  var needRows = startRow + rows.length;
+  var needColumns = startColumn + idcMaxRowLength(rows);
+  var rowsAdded = 0, columnsAdded = 0, written = 0, skipped = 0;
+  var overflowing = [];
+  var r, c, cell, text;
+
+  if (needRows > counts.rows || needColumns > counts.columns) {
+    if (!grow) {
+      IDC.fail('invalid_argument', 'The cells do not fit: they need ' + needRows + ' row(s) and ' + needColumns + ' column(s), the table has ' +
+        counts.rows + ' x ' + counts.columns + '. Pass grow true to add rows and columns.',
+        { rows_needed: needRows, columns_needed: needColumns, rows: counts.rows, columns: counts.columns });
+    }
+    try {
+      while (counts.rows + rowsAdded < needRows) { table.rows.add(LocationOptions.AT_END); rowsAdded += 1; }
+      while (counts.columns + columnsAdded < needColumns) { table.columns.add(LocationOptions.AT_END); columnsAdded += 1; }
+    } catch (e0) {
+      IDC.fail('script_error', 'InDesign could not add rows or columns: ' + String(e0.message ? e0.message : e0), null);
+    }
+    counts = idcTableCounts(table);
+  }
+
+  for (r = 0; r < rows.length; r++) {
+    for (c = 0; c < rows[r].length; c++) {
+      cell = idcCellAt(table, startRow + r, startColumn + c);
+      if (cell === null) { skipped += 1; continue; }
+      text = rows[r][c];
+      /* A-8.8: Platzhalter in Zellen sind in dieser Fassung nicht vorgesehen – nur Warnung. */
+      if (typeof text === 'string' && text.indexOf('{{') >= 0 && !ctx.placeholderWarned) {
+        ctx.placeholderWarned = true;
+        ctx.warn('Cell text contains "{{" – placeholders such as {{nbsp}} are not expanded in table cells in this version; they are written as they are.');
+      }
+      try {
+        if (text !== null) { cell.contents = text; }
+      } catch (e1) {
+        IDC.fail('script_error', 'InDesign could not write cell ' + (startRow + r) + '/' + (startColumn + c) + ': ' + String(e1.message ? e1.message : e1),
+          { row: startRow + r, column: startColumn + c });
+      }
+      if (paragraphStyle !== null) {
+        try { cell.texts.item(0).appliedParagraphStyle = paragraphStyle; } catch (e2) { ctx.warn('Paragraph style not applied in cell ' + (startRow + r) + '/' + (startColumn + c) + '.'); }
+      }
+      if (cellStyle !== null) {
+        try { cell.appliedCellStyle = cellStyle; } catch (e3) { ctx.warn('Cell style not applied in cell ' + (startRow + r) + '/' + (startColumn + c) + '.'); }
+      }
+      if (text !== null) { written += 1; }
+      overflowing.push({ row: startRow + r, column: startColumn + c });
+    }
+  }
+  if (skipped > 0) {
+    ctx.warn(skipped + ' cell(s) were skipped because they are part of a merged cell.');
+  }
+  /* Live 05.09.2026: direkt nach dem Schreiben meldet InDesign jede Zelle als uebergelaufen, bis neu umbrochen ist. */
+  try { table.recompose(); } catch (e5) { /* kennt die Laufzeit nicht */ }
+  overflowing = idcOverflowingCells(table, overflowing);
+  if (overflowing.length > 0) {
+    ctx.warn(overflowing.length + ' cell(s) overflow (Zelle mit Übersatz); widen the column or shorten the text.');
+  }
+  return { cells_written: written, cells_skipped: skipped, rows_added: rowsAdded, columns_added: columnsAdded, overflowing_cells: overflowing };
+}
+
+/* Aus einer Liste von Zellpositionen die, deren Zelle nach dem Umbruch ueberlaeuft. */
+function idcOverflowingCells(table, positions) {
+  var out = [], i, cell;
+  for (i = 0; i < positions.length; i++) {
+    cell = idcCellAt(table, positions[i].row, positions[i].column);
+    if (cell === null) { continue; }
+    try { if (cell.overflows === true) { out.push(positions[i]); } } catch (e) { /* unbekannt */ }
+  }
+  return out;
+}
+
+/*
+ * Gesamtbreite proportional auf die Spalten verteilen. table.width = x setzt
+ * in InDesign alle Spalten gleich breit (live 05.09.2026), deshalb selbst rechnen.
+ */
+function idcApplyTableWidth(table, width) {
+  var widths = idcColumnWidths(table), sum = 0, i, factor;
+  for (i = 0; i < widths.length; i++) { sum += widths[i]; }
+  if (widths.length === 0 || !(sum > 0)) {
+    try { table.width = width; } catch (e0) { IDC.fail('script_error', 'InDesign could not set the table width.', null); }
+    return;
+  }
+  factor = width / sum;
+  try {
+    for (i = 0; i < widths.length; i++) { table.columns.item(i).width = widths[i] * factor; }
+  } catch (e1) {
+    IDC.fail('script_error', 'InDesign could not set the column widths: ' + String(e1.message ? e1.message : e1), null);
+  }
+}
+
+/*
+ * Kopf-/Fusszeilen ueber rowType je Zeile umwidmen. headerRowCount/
+ * footerRowCount per Skript legen neue leere Zeilen an oder loeschen
+ * vorhandene samt Inhalt (live 05.09.2026) – deshalb nicht benutzen.
+ */
+function idcSetRowTypes(table, headerRows, footerRows) {
+  var counts = idcTableCounts(table), r, row, wanted, current, i;
+  var order = [];
+  if (typeof RowTypes === 'undefined') {
+    IDC.fail('invalid_state', 'This runtime has no RowTypes; header_rows/footer_rows cannot be changed.', null);
+  }
+  /* Erst alles, was Koerper werden soll, dann Kopf und Fuss – so bleiben die Bereiche zusammenhaengend. */
+  for (r = 0; r < counts.rows; r++) {
+    if (r < headerRows) { wanted = RowTypes.HEADER_ROW; }
+    else if (r >= counts.rows - footerRows) { wanted = RowTypes.FOOTER_ROW; }
+    else { wanted = RowTypes.BODY_ROW; }
+    order.push({ index: r, wanted: wanted, body: IDC.enumIs(wanted, RowTypes.BODY_ROW) });
+  }
+  for (i = 0; i < 2; i++) {
+    for (r = 0; r < order.length; r++) {
+      if ((i === 0) !== order[r].body) { continue; }
+      row = table.rows.item(order[r].index);
+      try { current = row.rowType; } catch (e0) { current = null; }
+      if (current !== null && IDC.enumIs(current, order[r].wanted)) { continue; }
+      try { row.rowType = order[r].wanted; } catch (e1) {
+        IDC.fail('script_error', 'InDesign could not change the type of row ' + order[r].index + ': ' + String(e1.message ? e1.message : e1),
+          { row: order[r].index });
+      }
+    }
+  }
+}
+
+function idcApplyColumnWidths(table, widths, field) {
+  var i, counts = idcTableCounts(table);
+  if (!IDC.isArray(widths) || widths.length === 0) {
+    IDC.fail('invalid_argument', field + ' must be a list of widths in mm, one per column.', { field: field });
+  }
+  if (widths.length !== counts.columns) {
+    IDC.fail('invalid_argument', field + ' lists ' + widths.length + ' width(s), the table has ' + counts.columns + ' column(s).',
+      { field: field, given: widths.length, columns: counts.columns });
+  }
+  for (i = 0; i < widths.length; i++) {
+    if (typeof widths[i] !== 'number' || !(widths[i] > 0) || widths[i] > 2000) {
+      IDC.fail('invalid_argument', field + '[' + i + '] must be a number above 0 (mm).', { field: field, index: i, value: widths[i] });
+    }
+  }
+  try {
+    for (i = 0; i < widths.length; i++) { table.columns.item(i).width = widths[i]; }
+  } catch (e) {
+    IDC.fail('script_error', 'InDesign could not set the column widths: ' + String(e.message ? e.message : e), null);
+  }
+}
+
+IDC.register('create_table', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcTextFrameArg(doc, args, 'frame_id');
+    var frame = found.item;
+    var story = idcStoryOf(frame);
+    var bodyRows = idcCountArg(args.rows, 'rows', 1, 1000, null);
+    var columns = idcCountArg(args.columns, 'columns', 1, 100, null);
+    var headerRows = idcCountArg(args.header_rows, 'header_rows', 0, 20, 0);
+    var footerRows = idcCountArg(args.footer_rows, 'footer_rows', 0, 20, 0);
+    var position = args.position === undefined || args.position === null ? 'end' : args.position;
+    var cells = null, tableStyle = null, paragraphStyle = null, cellStyle = null;
+    var insertAt, length, lastChar = '', addedReturn = false, table = null, description, writeResult = null;
+    var countBefore = 0, index = null, i;
+
+    if (bodyRows === null) { IDC.fail('invalid_argument', 'rows is required (body rows, 1 to 1000).', null); }
+    if (columns === null) { IDC.fail('invalid_argument', 'columns is required (1 to 100).', null); }
+    if (position !== 'end' && position !== 'start' && position !== 'replace') {
+      IDC.fail('invalid_argument', 'position must be end, start or replace.', { position: position });
+    }
+    if (args.cells !== undefined && args.cells !== null) {
+      cells = idcCellsArg(args.cells, 'cells');
+      if (cells.length > headerRows + bodyRows + footerRows || idcMaxRowLength(cells) > columns) {
+        IDC.fail('invalid_argument', 'cells has more rows or columns than the table (' + (headerRows + bodyRows + footerRows) + ' x ' + columns + ').',
+          { cell_rows: cells.length, cell_columns: idcMaxRowLength(cells), rows: headerRows + bodyRows + footerRows, columns: columns });
+      }
+    }
+    if (args.table_style !== undefined && args.table_style !== null) { tableStyle = idcTableStyleArg(doc, args.table_style, 'table_style'); }
+    if (args.cell_style !== undefined && args.cell_style !== null) { cellStyle = idcCellStyleArg(doc, args.cell_style, 'cell_style'); }
+    if (args.paragraph_style !== undefined && args.paragraph_style !== null) { paragraphStyle = idcParagraphStyleArg(doc, args.paragraph_style, 'paragraph_style'); }
+    if (args.column_widths_mm !== undefined && args.column_widths_mm !== null) {
+      if (!IDC.isArray(args.column_widths_mm) || args.column_widths_mm.length !== columns) {
+        IDC.fail('invalid_argument', 'column_widths_mm must list exactly ' + columns + ' width(s).', { columns: columns });
+      }
+      for (i = 0; i < columns; i++) {
+        if (typeof args.column_widths_mm[i] !== 'number' || !(args.column_widths_mm[i] > 0)) {
+          IDC.fail('invalid_argument', 'column_widths_mm[' + i + '] must be a number above 0 (mm).', { index: i, value: args.column_widths_mm[i] });
+        }
+      }
+    }
+    if (args.width_mm !== undefined && args.width_mm !== null) {
+      if (typeof args.width_mm !== 'number' || !(args.width_mm > 0) || args.width_mm > 2000) {
+        IDC.fail('invalid_argument', 'width_mm must be a number above 0 (mm).', { width_mm: args.width_mm });
+      }
+    }
+
+    try { countBefore = Number(story.tables.length); } catch (e0) { countBefore = 0; }
+    try { length = Number(story.characters.length); } catch (e1) { length = 0; }
+
+    if (position === 'replace') {
+      try { story.contents = ''; } catch (e2) {
+        IDC.fail('script_error', 'InDesign could not clear the story: ' + String(e2.message ? e2.message : e2), null);
+      }
+      length = 0;
+      countBefore = 0;
+      insertAt = 0;
+    } else if (position === 'start') {
+      insertAt = 0;
+    } else {
+      if (length > 0) {
+        try { lastChar = String(story.characters.item(length - 1).contents); } catch (e3) { lastChar = ''; }
+        if (lastChar !== '\r') {
+          try { story.insertionPoints.item(length).contents = '\r'; } catch (e4) {
+            IDC.fail('script_error', 'InDesign could not add a paragraph return before the table: ' + String(e4.message ? e4.message : e4), null);
+          }
+          length += 1;
+          addedReturn = true;
+        }
+      }
+      insertAt = length;
+    }
+
+    try {
+      table = story.insertionPoints.item(insertAt).tables.add(LocationOptions.AT_END, undefined, {
+        bodyRowCount: bodyRows,
+        columnCount: columns,
+        headerRowCount: headerRows,
+        footerRowCount: footerRows
+      });
+    } catch (e5) {
+      IDC.fail('script_error', 'InDesign could not create the table: ' + String(e5.message ? e5.message : e5),
+        { frame_id: args.frame_id, rows: bodyRows, columns: columns });
+    }
+    table = IDC.concrete(table);
+
+    if (tableStyle !== null) {
+      try { table.appliedTableStyle = tableStyle; } catch (e6) { ctx.warn('Table style "' + args.table_style + '" could not be applied.'); }
+    }
+    if (args.column_widths_mm !== undefined && args.column_widths_mm !== null) {
+      idcApplyColumnWidths(table, args.column_widths_mm, 'column_widths_mm');
+    } else if (args.width_mm !== undefined && args.width_mm !== null) {
+      idcApplyTableWidth(table, args.width_mm);
+    }
+    if (cells === null && (paragraphStyle !== null || cellStyle !== null)) {
+      /* Formate ohne Inhalte: alle Zellen einmal anfassen, Inhalt bleibt leer. */
+      cells = idcEmptyMatrix(headerRows + bodyRows + footerRows, columns);
+    }
+    if (cells !== null) {
+      writeResult = idcWriteCells(ctx, doc, table, cells, 0, 0, paragraphStyle, cellStyle, false);
+    }
+
+    /* Index der neuen Tabelle in der Story. */
+    try {
+      for (i = 0; i < story.tables.length; i++) {
+        if (Number(story.tables.item(i).id) === Number(table.id)) { index = i; break; }
+      }
+    } catch (e8) { index = null; }
+
+    description = idcDescribeTable(table, story, index, countBefore + 1);
+    description.position = position;
+    description.paragraph_return_added = addedReturn;
+    description.cells_written = writeResult === null ? 0 : writeResult.cells_written;
+    description.overflowing_cells = writeResult === null ? [] : writeResult.overflowing_cells;
+    description.overset = idcOverflows(frame);
+    if (description.overset === true) {
+      ctx.warn('The story overflows after adding the table (Übersatz); enlarge the frame or thread another one.');
+    }
+    if (addedReturn) {
+      ctx.warn('A paragraph return was added before the table so it starts its own paragraph.');
+    }
+    ctx.changes = { created_table_ids: [description.table_id], modified_frame_ids: [Number(frame.id)] };
+    return description;
+  });
+
+function idcEmptyMatrix(rows, columns) {
+  var out = [], r, c, row;
+  for (r = 0; r < rows; r++) {
+    row = [];
+    for (c = 0; c < columns; c++) { row.push(null); }
+    out.push(row);
+  }
+  return out;
+}
+
+IDC.register('set_table_cells', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var target = idcTableArg(doc, args);
+    var rows = idcCellsArg(args.cells, 'cells');
+    var startRow = idcCountArg(args.start_row, 'start_row', 0, 100000, 0);
+    var startColumn = idcCountArg(args.start_column, 'start_column', 0, 1000, 0);
+    var grow = args.grow === true;
+    var paragraphStyle = null, cellStyle = null, result, description;
+
+    if (args.paragraph_style !== undefined && args.paragraph_style !== null) { paragraphStyle = idcParagraphStyleArg(doc, args.paragraph_style, 'paragraph_style'); }
+    if (args.cell_style !== undefined && args.cell_style !== null) { cellStyle = idcCellStyleArg(doc, args.cell_style, 'cell_style'); }
+
+    result = idcWriteCells(ctx, doc, target.table, rows, startRow, startColumn, paragraphStyle, cellStyle, grow);
+    description = idcDescribeTable(target.table, target.story, target.index, target.count);
+    description.start_row = startRow;
+    description.start_column = startColumn;
+    description.cells_written = result.cells_written;
+    description.cells_skipped = result.cells_skipped;
+    description.rows_added = result.rows_added;
+    description.columns_added = result.columns_added;
+    description.overflowing_cells = result.overflowing_cells;
+    description.overset = idcOverflows(target.frame);
+    if (description.overset === true) {
+      ctx.warn('The story overflows (Übersatz) after writing the cells.');
+    }
+    ctx.changes = { modified_table_ids: [description.table_id], modified_frame_ids: [Number(target.frame.id)] };
+    return description;
+  });
+
+IDC.register('set_table_style', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var target = idcTableArg(doc, args);
+    var table = target.table;
+    var given = 0, changed = false;
+    var tableStyle = null, cellStyle = null, scope, counts, description;
+    var cellsStyled = 0, r, c, cell, type, i;
+
+    if (args.table_style !== undefined && args.table_style !== null) { tableStyle = idcTableStyleArg(doc, args.table_style, 'table_style'); given += 1; }
+    if (args.cell_style !== undefined && args.cell_style !== null) { cellStyle = idcCellStyleArg(doc, args.cell_style, 'cell_style'); given += 1; }
+    scope = args.cell_style_scope === undefined || args.cell_style_scope === null ? 'all' : args.cell_style_scope;
+    if (scope !== 'all' && scope !== 'header' && scope !== 'body' && scope !== 'footer') {
+      IDC.fail('invalid_argument', 'cell_style_scope must be all, header, body or footer.', { cell_style_scope: scope });
+    }
+    if (args.column_widths_mm !== undefined && args.column_widths_mm !== null) { given += 1; }
+    if (args.width_mm !== undefined && args.width_mm !== null) {
+      if (typeof args.width_mm !== 'number' || !(args.width_mm > 0) || args.width_mm > 2000) {
+        IDC.fail('invalid_argument', 'width_mm must be a number above 0 (mm).', { width_mm: args.width_mm });
+      }
+      given += 1;
+    }
+    if (args.header_rows !== undefined && args.header_rows !== null) { idcCountArg(args.header_rows, 'header_rows', 0, 20, 0); given += 1; }
+    if (args.footer_rows !== undefined && args.footer_rows !== null) { idcCountArg(args.footer_rows, 'footer_rows', 0, 20, 0); given += 1; }
+    if (given === 0) {
+      IDC.fail('invalid_argument', 'Pass at least one of table_style, cell_style, column_widths_mm, width_mm, header_rows, footer_rows.', null);
+    }
+
+    if (tableStyle !== null) {
+      try { table.appliedTableStyle = tableStyle; changed = true; } catch (e0) {
+        IDC.fail('script_error', 'InDesign could not apply table style "' + args.table_style + '": ' + String(e0.message ? e0.message : e0), null);
+      }
+    }
+    counts = idcTableCounts(table);
+    if ((args.header_rows !== undefined && args.header_rows !== null) || (args.footer_rows !== undefined && args.footer_rows !== null)) {
+      var headerWanted = args.header_rows === undefined || args.header_rows === null ? counts.header_rows : args.header_rows;
+      var footerWanted = args.footer_rows === undefined || args.footer_rows === null ? counts.footer_rows : args.footer_rows;
+      if (headerWanted + footerWanted >= counts.rows) {
+        IDC.fail('invalid_argument', 'header_rows and footer_rows together must leave at least one body row (table has ' + counts.rows + ' rows).',
+          { header_rows: headerWanted, footer_rows: footerWanted, rows: counts.rows });
+      }
+      if (headerWanted !== counts.header_rows || footerWanted !== counts.footer_rows) {
+        idcSetRowTypes(table, headerWanted, footerWanted);
+        changed = true;
+      }
+    }
+    if (args.column_widths_mm !== undefined && args.column_widths_mm !== null) {
+      idcApplyColumnWidths(table, args.column_widths_mm, 'column_widths_mm');
+      changed = true;
+    } else if (args.width_mm !== undefined && args.width_mm !== null) {
+      idcApplyTableWidth(table, args.width_mm);
+      changed = true;
+    }
+    if (cellStyle !== null) {
+      counts = idcTableCounts(table);
+      for (r = 0; r < counts.rows; r++) {
+        type = idcRowType(table, r);
+        if (scope !== 'all' && scope !== type) { continue; }
+        for (c = 0; c < counts.columns; c++) {
+          cell = idcCellAt(table, r, c);
+          if (cell === null) { continue; }
+          try { cell.appliedCellStyle = cellStyle; cellsStyled += 1; } catch (e4) { /* naechste */ }
+        }
+      }
+      changed = changed || cellsStyled > 0;
+    }
+
+    description = idcDescribeTable(table, target.story, target.index, target.count);
+    description.cell_style = cellStyle === null ? null : String(cellStyle.name);
+    description.cell_style_scope = cellStyle === null ? null : scope;
+    description.cells_styled = cellsStyled;
+    description.row_heights_mm = idcRowHeights(table);
+    description.overset = idcOverflows(target.frame);
+    description.changed = changed;
+    if (description.overset === true) {
+      ctx.warn('The story overflows (Übersatz) after the change; frame_id is null while the table sits in overset.');
+    }
+    if (changed) { ctx.changes = { modified_table_ids: [description.table_id], modified_frame_ids: [Number(target.frame.id)] }; }
+    return description;
+  });
+
+IDC.register('get_table', { needs_document: true, read_only: true, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var target = idcTableArg(doc, args);
+    var table = target.table;
+    var maxChars = idcCountArg(args.max_chars_per_cell, 'max_chars_per_cell', 1, 100000, 200);
+    var counts = idcTableCounts(table);
+    var rowsText = [], merged = [], overflowing = [], cellStyles = {}, styleNames = [];
+    var truncated = false, r, c, cell, text, row, span, name, description, key;
+
+    for (r = 0; r < counts.rows; r++) {
+      row = [];
+      for (c = 0; c < counts.columns; c++) {
+        cell = idcCellAt(table, r, c);
+        if (cell === null) { row.push(null); continue; }
+        try { text = String(cell.contents); } catch (e0) { text = ''; }
+        if (text.length > maxChars) { text = text.substring(0, maxChars); truncated = true; }
+        row.push(text);
+        try {
+          span = { row: r, column: c, row_span: Number(cell.rowSpan), column_span: Number(cell.columnSpan) };
+          if (span.row_span > 1 || span.column_span > 1) { merged.push(span); }
+        } catch (e1) { /* keine Angabe */ }
+        try { if (cell.overflows === true) { overflowing.push({ row: r, column: c }); } } catch (e2) { /* unbekannt */ }
+        try {
+          name = String(cell.appliedCellStyle.name);
+          if (!IDC.hasOwn(cellStyles, name)) { cellStyles[name] = 0; }
+          cellStyles[name] += 1;
+        } catch (e3) { /* ohne */ }
+      }
+      rowsText.push(row);
+    }
+    for (key in cellStyles) {
+      if (IDC.hasOwn(cellStyles, key)) { styleNames.push({ name: key, cells: cellStyles[key] }); }
+    }
+
+    description = idcDescribeTable(table, target.story, target.index, target.count);
+    description.row_heights_mm = idcRowHeights(table);
+    description.row_types = [];
+    for (r = 0; r < counts.rows; r++) { description.row_types.push(idcRowType(table, r)); }
+    description.rows_text = rowsText;
+    description.merged_cells = merged;
+    description.overflowing_cells = overflowing;
+    description.cell_styles = styleNames;
+    description.truncated = truncated;
+    description.max_chars_per_cell = maxChars;
+    description.overset = idcOverflows(target.frame);
+    description.available_table_styles = idcStyleNames(doc.allTableStyles);
+    description.available_cell_styles = idcStyleNames(doc.allCellStyles);
+    if (overflowing.length > 0) {
+      ctx.warn(overflowing.length + ' cell(s) overflow (Zelle mit Übersatz).');
+    }
+    return description;
+  });