layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/37-layout.js

@@ -0,0 +1,760 @@
+/* Bereich C – Satzspiegel, Raster, Hilfslinien. */
+
+/*
+ * Stege am linken und rechten Seitenrand.
+ *
+ * InDesigns Skriptschnittstelle kennt nur marginPreferences.left/right. Bei
+ * Doppelseiten bedeutet left "innen" (Bundsteg) und right "aussen"; auf einer
+ * linken Seite liegt der Bundsteg also rechts. Das ist die einzige Stelle,
+ * an der diese Zuordnung (E-20) steht – Adobes Scripting-Guide rechnet den
+ * Satzspiegel linker Seiten genauso (x1 = right, x2 = Breite - left).
+ */
+function idcEdgeMargins(page, facing) {
+  var prefs = page.marginPreferences;
+  var left = Number(prefs.left);
+  var right = Number(prefs.right);
+  if (facing && IDC.pageSide(page) === 'LEFT_HAND') {
+    return { left_edge: right, right_edge: left };
+  }
+  return { left_edge: left, right_edge: right };
+}
+
+function idcFacing(doc) {
+  try { return doc.documentPreferences.facingPages === true; } catch (e) { return false; }
+}
+
+/* Position der Seite in ihrem Bogen und ihr Versatz vom Bogenanfang in mm. */
+function idcSpreadPlacement(page) {
+  var spread = null;
+  var i, other, offset = 0, position = 0, count = 0;
+  try { spread = page.parent; } catch (e) { spread = null; }
+  if (spread === null) { return { spread_index: null, spread_page_count: 1, spread_position: 0, page_offset_in_spread_mm: 0 }; }
+  count = spread.pages.length;
+  for (i = 0; i < count; i++) {
+    other = spread.pages.item(i);
+    if (Number(other.id) === Number(page.id)) { position = i; break; }
+    offset += IDC.pageSize(other).width;
+  }
+  return {
+    spread_index: IDC.spreadIndex(spread),
+    spread_page_count: count,
+    spread_position: position,
+    page_offset_in_spread_mm: IDC.round(offset)
+  };
+}
+
+/* Gleichmaessige Spaltenpositionen relativ zum linken Satzspiegelrand. */
+function idcEvenColumnPositions(typeWidth, count, gutter) {
+  var positions = [];
+  var columnWidth = (typeWidth - (count - 1) * gutter) / count;
+  var i, x = 0;
+  for (i = 0; i < count; i++) {
+    positions.push(IDC.round(x));
+    positions.push(IDC.round(x + columnWidth));
+    x += columnWidth + gutter;
+  }
+  return { positions: positions, column_width: IDC.round(columnWidth) };
+}
+
+function idcReadColumnPositions(page) {
+  var raw, out = [], i;
+  try { raw = page.marginPreferences.columnsPositions; } catch (e) { return null; }
+  if (!raw || raw.length === undefined || raw.length === 0) { return null; }
+  for (i = 0; i < raw.length; i++) { out.push(IDC.round(Number(raw[i]))); }
+  return out;
+}
+
+function idcPositionsMatch(actual, expected) {
+  var i;
+  if (actual === null || actual.length !== expected.length) { return false; }
+  for (i = 0; i < actual.length; i++) {
+    if (Math.abs(actual[i] - expected[i]) > 0.01) { return false; }
+  }
+  return true;
+}
+
+/* Satzspiegel einer Seite als Ergebniszeile. */
+function idcDescribeGrid(page, isParent, facing) {
+  var prefs = page.marginPreferences;
+  var size = IDC.pageSize(page);
+  var edges = idcEdgeMargins(page, facing);
+  var top = Number(prefs.top);
+  var bottom = Number(prefs.bottom);
+  var count = Number(prefs.columnCount);
+  var gutter = Number(prefs.columnGutter);
+  var typeWidth = size.width - edges.left_edge - edges.right_edge;
+  var typeHeight = size.height - top - bottom;
+  var even = idcEvenColumnPositions(typeWidth, count > 0 ? count : 1, gutter);
+  var actual = idcReadColumnPositions(page);
+  var placement = idcSpreadPlacement(page);
+  var margins = {
+    top: IDC.round(top),
+    bottom: IDC.round(bottom),
+    left: IDC.round(Number(prefs.left)),
+    right: IDC.round(Number(prefs.right))
+  };
+  if (facing) {
+    margins.inside = margins.left;
+    margins.outside = margins.right;
+  }
+  return {
+    page_id: Number(page.id),
+    name: String(page.name),
+    is_parent_page: isParent,
+    side: IDC.pageSide(page),
+    spread_index: placement.spread_index,
+    spread_page_count: placement.spread_page_count,
+    spread_position: placement.spread_position,
+    page_offset_in_spread_mm: placement.page_offset_in_spread_mm,
+    parent: idcAppliedParentName(page),
+    page_size_mm: { width: size.width, height: size.height },
+    margins_mm: margins,
+    column_count: count,
+    column_gutter_mm: IDC.round(gutter),
+    type_area_mm: {
+      x: IDC.round(edges.left_edge),
+      y: IDC.round(top),
+      width: IDC.round(typeWidth),
+      height: IDC.round(typeHeight)
+    },
+    column_width_mm: even.column_width,
+    columns_positions_mm: actual === null ? even.positions : actual,
+    custom_column_positions: actual !== null && !idcPositionsMatch(actual, even.positions)
+  };
+}
+
+/* Alle Seiten (Dokument, dann Musterseiten) als [{page, is_parent}]. */
+function idcAllPages(doc, includeParents) {
+  var out = [];
+  var i, j, spread;
+  for (i = 0; i < doc.pages.length; i++) {
+    out.push({ page: doc.pages.item(i), is_parent: false });
+  }
+  if (includeParents) {
+    for (i = 0; i < doc.masterSpreads.length; i++) {
+      spread = doc.masterSpreads.item(i);
+      for (j = 0; j < spread.pages.length; j++) {
+        out.push({ page: spread.pages.item(j), is_parent: true });
+      }
+    }
+  }
+  return out;
+}
+
+function idcGridKey(entry) {
+  return [entry.margins_mm.top, entry.margins_mm.bottom, entry.margins_mm.left, entry.margins_mm.right,
+    entry.column_count, entry.column_gutter_mm].join('|');
+}
+
+/* Grundlinienraster dokumentweit. */
+function idcReadBaselineGrid(doc, ctx) {
+  var grid = doc.gridPreferences;
+  var startMm = null, incMm = null, incPt = null, rawRel = null, relative = 'unknown', shown = null, threshold = null;
+  var rawStart = null, rawInc = null;
+  try { rawStart = Number(grid.baselineStart); startMm = IDC.round(rawStart); } catch (e1) { startMm = null; rawStart = null; }
+  try { rawInc = Number(grid.baselineDivision); incMm = IDC.round(rawInc); } catch (e2) { incMm = null; rawInc = null; }
+  try { incPt = IDC.inPoints(function () { return IDC.round(Number(grid.baselineDivision), 3); }); } catch (e3) { incPt = null; }
+  try { shown = grid.baselineGridShown === true; } catch (e4) { shown = null; }
+  try { threshold = Number(grid.baselineViewThreshold); } catch (e5) { threshold = null; }
+  try {
+    rawRel = grid.baselineGridRelativeOption;
+    if (typeof BaselineGridRelativeOption !== 'undefined') {
+      if (IDC.enumIs(rawRel, BaselineGridRelativeOption.TOP_OF_PAGE_OF_BASELINE_GRID_RELATIVE_OPTION)) { relative = 'top_of_page'; }
+      else if (IDC.enumIs(rawRel, BaselineGridRelativeOption.TOP_OF_MARGIN_OF_BASELINE_GRID_RELATIVE_OPTION)) { relative = 'top_of_margin'; }
+    }
+  } catch (e6) { rawRel = null; }
+  if (relative === 'unknown') {
+    ctx.warn('Baseline grid reference (relative_to) is unknown; the check below assumes top of page.');
+  }
+  return {
+    start_mm: startMm,
+    increment_mm: incMm,
+    increment_pt: incPt,
+    relative_to: relative,
+    relative_to_raw: rawRel === null || rawRel === undefined ? null : String(rawRel),
+    shown: shown,
+    view_threshold: threshold,
+    /* ungerundet fuer die Rechnung; wird vor der Ausgabe entfernt */
+    raw_start: rawStart,
+    raw_increment: rawInc
+  };
+}
+
+function idcStripRaw(baseline) {
+  var out = {}, k;
+  for (k in baseline) {
+    if (IDC.hasOwn(baseline, k) && k !== 'raw_start' && k !== 'raw_increment') { out[k] = baseline[k]; }
+  }
+  return out;
+}
+
+/* Geht das Raster im Satzspiegel der ersten Dokumentseite auf? */
+function idcBaselineCheck(baseline, firstGrid, ctx) {
+  var area = firstGrid.type_area_mm;
+  var first, lines, last, remainder, startsAtTop;
+  var start = baseline.raw_start, inc = baseline.raw_increment;
+  if (start === null || inc === null || isNaN(start) || isNaN(inc) || inc <= 0) {
+    return { first_line_mm: null, starts_at_type_area_top: null, lines_in_type_area: null, last_line_mm: null, remainder_below_mm: null };
+  }
+  first = baseline.relative_to === 'top_of_margin' ? area.y + start : start;
+  /* erste Rasterlinie im Satzspiegel */
+  while (first < area.y - 0.005) { first += inc; }
+  startsAtTop = Math.abs(first - area.y) <= 0.01;
+  lines = Math.floor((area.y + area.height - first) / inc + 0.0001) + 1;
+  if (lines < 0) { lines = 0; }
+  last = lines > 0 ? first + (lines - 1) * inc : null;
+  remainder = last === null ? null : IDC.round(area.y + area.height - last);
+  if (remainder !== null && remainder > 0.01) {
+    ctx.warn('The baseline grid does not fit the type area (Satzspiegel): ' + remainder +
+      ' mm remain below the last grid line on page ' + firstGrid.name + '.');
+  }
+  return {
+    first_line_mm: IDC.round(first),
+    starts_at_type_area_top: startsAtTop,
+    lines_in_type_area: lines,
+    last_line_mm: last === null ? null : IDC.round(last),
+    remainder_below_mm: remainder
+  };
+}
+
+function idcReadBleedSlug(doc, ctx) {
+  var prefs = doc.documentPreferences;
+  var bleed = {
+    top: IDC.round(prefs.documentBleedTopOffset),
+    left: IDC.round(prefs.documentBleedInsideOrLeftOffset),
+    bottom: IDC.round(prefs.documentBleedBottomOffset),
+    right: IDC.round(prefs.documentBleedOutsideOrRightOffset)
+  };
+  bleed.uniform = bleed.top === bleed.left && bleed.top === bleed.bottom && bleed.top === bleed.right;
+  if (bleed.top === 0 && bleed.left === 0 && bleed.bottom === 0 && bleed.right === 0) {
+    ctx.warn('Bleed (Anschnitt) is 0 mm on every edge; set_document_bleed before exporting for print.');
+  }
+  return {
+    bleed_mm: bleed,
+    slug_mm: {
+      top: IDC.round(prefs.slugTopOffset),
+      left: IDC.round(prefs.slugInsideOrLeftOffset),
+      bottom: IDC.round(prefs.slugBottomOffset),
+      right: IDC.round(prefs.slugRightOrOutsideOffset)
+    }
+  };
+}
+
+IDC.register('get_layout_grid', { needs_document: true, read_only: true, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var includeParents = args.include_parent_pages === false ? false : true;
+    var facing = idcFacing(doc);
+    var all = idcAllPages(doc, includeParents);
+    var pages = [];
+    var groups = [];
+    var groupByKey = {};
+    var i, entry, key, group, baseline, check, bleedSlug, firstDocGrid = null;
+
+    for (i = 0; i < all.length; i++) {
+      entry = idcDescribeGrid(all[i].page, all[i].is_parent, facing);
+      pages.push(entry);
+      if (firstDocGrid === null && !entry.is_parent_page) { firstDocGrid = entry; }
+      key = idcGridKey(entry);
+      if (!IDC.hasOwn(groupByKey, key)) {
+        group = {
+          margins_mm: entry.margins_mm,
+          columns: entry.column_count,
+          gutter_mm: entry.column_gutter_mm,
+          page_ids: []
+        };
+        groupByKey[key] = group;
+        groups.push(group);
+      }
+      groupByKey[key].page_ids.push(entry.page_id);
+    }
+
+    baseline = idcReadBaselineGrid(doc, ctx);
+    check = firstDocGrid === null
+      ? { first_line_mm: null, starts_at_type_area_top: null, lines_in_type_area: null, last_line_mm: null, remainder_below_mm: null }
+      : idcBaselineCheck(baseline, firstDocGrid, ctx);
+    bleedSlug = idcReadBleedSlug(doc, ctx);
+
+    return {
+      facing_pages: facing,
+      include_parent_pages: includeParents,
+      pages: pages,
+      page_count: pages.length,
+      distinct_grids: groups,
+      is_uniform: groups.length <= 1,
+      baseline_grid: idcStripRaw(baseline),
+      baseline_grid_check: check,
+      bleed_mm: bleedSlug.bleed_mm,
+      slug_mm: bleedSlug.slug_mm
+    };
+  });
+
+/* ---------------------------------------------------------- set_layout_grid */
+
+function idcOptionalNumber(args, key, min, max) {
+  var v = args[key];
+  if (v === undefined || v === null) { return null; }
+  if (typeof v !== 'number' || !isFinite(v)) {
+    IDC.fail('invalid_argument', key + ' must be a number.', { value: v });
+  }
+  if (v < min || v > max) {
+    IDC.fail('invalid_argument', key + ' must be between ' + min + ' and ' + max + '.', { value: v });
+  }
+  return v;
+}
+
+/* Seitenauswahl fuer set_layout_grid / delete_guides: page_ids oder alle. */
+function idcSelectPages(doc, args, includeParents) {
+  var ids = args.page_ids;
+  var out = [], i, found;
+  if (ids === undefined || ids === null) { return idcAllPages(doc, includeParents); }
+  if (!IDC.isArray(ids) || ids.length === 0) {
+    IDC.fail('invalid_argument', 'page_ids must be a non-empty array of page ids (omit it for all pages).', null);
+  }
+  for (i = 0; i < ids.length; i++) {
+    found = IDC.pageById(doc, ids[i]);
+    if (found === null) {
+      IDC.fail('not_found', 'No page with page_id ' + ids[i] + ' in this document.', { page_id: ids[i] });
+    }
+    if (found.is_parent_page && !includeParents) {
+      IDC.fail('invalid_argument', 'page_id ' + ids[i] + ' is a master page but include_parent_pages is false.', { page_id: ids[i] });
+    }
+    out.push({ page: found.page, is_parent: found.is_parent_page });
+  }
+  return out;
+}
+
+function idcApplyBaselineGrid(doc, spec, ctx) {
+  var grid = doc.gridPreferences;
+  var changed = false;
+  if (!spec || typeof spec !== 'object') {
+    IDC.fail('invalid_argument', 'baseline_grid must be an object { start_mm, increment_pt, relative_to }.', null);
+  }
+  if (spec.increment_pt !== undefined && spec.increment_pt !== null) {
+    if (typeof spec.increment_pt !== 'number' || spec.increment_pt <= 0) {
+      IDC.fail('invalid_argument', 'baseline_grid.increment_pt must be a number greater than 0.', spec);
+    }
+    IDC.inPoints(function () { grid.baselineDivision = spec.increment_pt; });
+    changed = true;
+  }
+  if (spec.start_mm !== undefined && spec.start_mm !== null) {
+    if (typeof spec.start_mm !== 'number' || spec.start_mm < 0) {
+      IDC.fail('invalid_argument', 'baseline_grid.start_mm must be a number of 0 or more.', spec);
+    }
+    grid.baselineStart = spec.start_mm;
+    changed = true;
+  }
+  if (spec.relative_to !== undefined && spec.relative_to !== null) {
+    if (typeof BaselineGridRelativeOption === 'undefined') {
+      ctx.warn('This runtime has no BaselineGridRelativeOption; relative_to was not set.');
+    } else if (spec.relative_to === 'top_of_page') {
+      grid.baselineGridRelativeOption = BaselineGridRelativeOption.TOP_OF_PAGE_OF_BASELINE_GRID_RELATIVE_OPTION;
+      changed = true;
+    } else if (spec.relative_to === 'top_of_margin') {
+      grid.baselineGridRelativeOption = BaselineGridRelativeOption.TOP_OF_MARGIN_OF_BASELINE_GRID_RELATIVE_OPTION;
+      changed = true;
+    } else {
+      IDC.fail('invalid_argument', 'baseline_grid.relative_to must be "top_of_page" or "top_of_margin".', spec);
+    }
+  }
+  return changed;
+}
+
+IDC.register('set_layout_grid', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var includeParents = args.include_parent_pages === false ? false : true;
+    var facing = idcFacing(doc);
+    var margins = null;
+    var count = idcOptionalNumber(args, 'column_count', 1, 30);
+    var gutter = idcOptionalNumber(args, 'column_gutter_mm', 0, 100);
+    var targets, i, page, prefs, entry, even, changed = [], ids = [], anything = false, baselineChanged = false, k;
+    var keys = ['top', 'left', 'bottom', 'right'];
+
+    if (count !== null && count !== Math.floor(count)) {
+      IDC.fail('invalid_argument', 'column_count must be a whole number.', { value: count });
+    }
+    if (args.margins_mm !== undefined && args.margins_mm !== null) {
+      if (typeof args.margins_mm !== 'object') {
+        IDC.fail('invalid_argument', 'margins_mm must be an object with top/left/bottom/right (all optional).', null);
+      }
+      margins = {};
+      for (k = 0; k < keys.length; k++) {
+        if (args.margins_mm[keys[k]] !== undefined && args.margins_mm[keys[k]] !== null) {
+          if (typeof args.margins_mm[keys[k]] !== 'number' || args.margins_mm[keys[k]] < 0) {
+            IDC.fail('invalid_argument', 'margins_mm.' + keys[k] + ' must be a number of 0 or more.', args.margins_mm);
+          }
+          margins[keys[k]] = args.margins_mm[keys[k]];
+          anything = true;
+        }
+      }
+      if (facing && (margins.left !== undefined || margins.right !== undefined)) {
+        ctx.warn('Facing pages: margins_mm.left is the inside margin (Bundsteg), margins_mm.right the outside margin.');
+      }
+    }
+    if (count !== null || gutter !== null) { anything = true; }
+    if (args.baseline_grid !== undefined && args.baseline_grid !== null) {
+      baselineChanged = idcApplyBaselineGrid(doc, args.baseline_grid, ctx);
+      anything = anything || baselineChanged;
+    }
+    if (!anything) {
+      IDC.fail('invalid_argument', 'Nothing to set: pass margins_mm, column_count, column_gutter_mm or baseline_grid.', null);
+    }
+
+    targets = idcSelectPages(doc, args, includeParents);
+
+    for (i = 0; i < targets.length; i++) {
+      page = targets[i].page;
+      prefs = page.marginPreferences;
+      try {
+        if (margins !== null) {
+          if (margins.top !== undefined) { prefs.top = margins.top; }
+          if (margins.bottom !== undefined) { prefs.bottom = margins.bottom; }
+          if (margins.left !== undefined) { prefs.left = margins.left; }
+          if (margins.right !== undefined) { prefs.right = margins.right; }
+        }
+        if (count !== null) { prefs.columnCount = count; }
+        if (gutter !== null) { prefs.columnGutter = gutter; }
+        /* Spaltenpositionen gleichmaessig neu verteilen (randrelativ) */
+        entry = idcDescribeGrid(page, targets[i].is_parent, facing);
+        even = idcEvenColumnPositions(entry.type_area_mm.width, entry.column_count, entry.column_gutter_mm);
+        try { prefs.columnsPositions = even.positions; } catch (ec) { /* aeltere Versionen: nur lesbar */ }
+      } catch (e) {
+        IDC.fail('script_error', 'InDesign could not set the layout grid on page ' + String(page.name) + ': ' +
+          String(e.message ? e.message : e), { page_id: Number(page.id) });
+      }
+      entry = idcDescribeGrid(page, targets[i].is_parent, facing);
+      if (entry.custom_column_positions) {
+        ctx.warn('Page ' + entry.name + ': column positions do not lie on the even grid after writing (' +
+          entry.columns_positions_mm.join(', ') + ').');
+      }
+      if (entry.type_area_mm.width <= 0 || entry.type_area_mm.height <= 0) {
+        ctx.warn('Page ' + entry.name + ': margins leave no type area (Satzspiegel) – width ' +
+          entry.type_area_mm.width + ' mm, height ' + entry.type_area_mm.height + ' mm.');
+      }
+      changed.push({
+        page_id: entry.page_id,
+        name: entry.name,
+        is_parent_page: entry.is_parent_page,
+        margins_mm: entry.margins_mm,
+        column_count: entry.column_count,
+        column_gutter_mm: entry.column_gutter_mm,
+        type_area_mm: entry.type_area_mm,
+        column_width_mm: entry.column_width_mm,
+        columns_positions_mm: entry.columns_positions_mm
+      });
+      ids.push(entry.page_id);
+    }
+
+    /* Ohne page_ids gelten die Werte auch fuer neue Seiten (Dokumentvorgabe). */
+    var defaultsChanged = false;
+    if ((args.page_ids === undefined || args.page_ids === null) && (margins !== null || count !== null || gutter !== null)) {
+      try {
+        prefs = doc.marginPreferences;
+        if (margins !== null) {
+          if (margins.top !== undefined) { prefs.top = margins.top; }
+          if (margins.bottom !== undefined) { prefs.bottom = margins.bottom; }
+          if (margins.left !== undefined) { prefs.left = margins.left; }
+          if (margins.right !== undefined) { prefs.right = margins.right; }
+        }
+        if (count !== null) { prefs.columnCount = count; }
+        if (gutter !== null) { prefs.columnGutter = gutter; }
+        defaultsChanged = true;
+      } catch (e2) { defaultsChanged = false; }
+    }
+
+    ctx.changes = { modified_page_ids: ids, modified_document_ids: [Number(doc.id)] };
+    var out = {
+      changed_pages: changed,
+      changed_page_count: changed.length,
+      document_defaults_changed: defaultsChanged
+    };
+    if (baselineChanged) { out.baseline_grid = idcStripRaw(idcReadBaselineGrid(doc, ctx)); }
+    return out;
+  });
+
+/* -------------------------------------------------------------- Hilfslinien */
+
+var IDC_UI_COLOR_NAMES = ['BLACK', 'BLUE', 'BRICK_RED', 'BROWN', 'BURGUNDY', 'CHARCOAL', 'CUTE_TEAL', 'CYAN',
+  'DARK_BLUE', 'DARK_GREEN', 'FIESTA', 'GOLD', 'GRASS_GREEN', 'GRAY', 'GREEN', 'GRID_BLUE', 'GRID_GREEN',
+  'GRID_ORANGE', 'LAVENDER', 'LIGHT_BLUE', 'LIGHT_GRAY', 'LIGHT_OLIVE', 'LIPSTICK', 'MAGENTA', 'OCHRE',
+  'OLIVE_GREEN', 'ORANGE', 'PEACH', 'PINK', 'PURPLE', 'RED', 'SULPHUR', 'TAN', 'TEAL', 'VIOLET', 'WHITE', 'YELLOW'];
+
+function idcHex2(n) {
+  var h = Math.round(Number(n)).toString(16);
+  return h.length < 2 ? '0' + h : h;
+}
+
+function idcGuideColorName(value) {
+  var i;
+  if (value === null || value === undefined) { return null; }
+  if (IDC.isArray(value) && value.length === 3) {
+    return '#' + idcHex2(value[0]) + idcHex2(value[1]) + idcHex2(value[2]);
+  }
+  if (typeof UIColors !== 'undefined') {
+    for (i = 0; i < IDC_UI_COLOR_NAMES.length; i++) {
+      try {
+        if (UIColors[IDC_UI_COLOR_NAMES[i]] !== undefined && IDC.enumIs(value, UIColors[IDC_UI_COLOR_NAMES[i]])) {
+          return IDC_UI_COLOR_NAMES[i].toLowerCase();
+        }
+      } catch (e) { /* naechster */ }
+    }
+  }
+  return String(value);
+}
+
+function idcGuideOrientation(guide) {
+  var o = null;
+  try { o = guide.orientation; } catch (e) { return 'unknown'; }
+  if (typeof HorizontalOrVertical !== 'undefined') {
+    if (IDC.enumIs(o, HorizontalOrVertical.HORIZONTAL)) { return 'horizontal'; }
+    if (IDC.enumIs(o, HorizontalOrVertical.VERTICAL)) { return 'vertical'; }
+  }
+  return String(o).toLowerCase().indexOf('hor') >= 0 ? 'horizontal' : 'vertical';
+}
+
+/* Seiten eines Bogens mit ihrem Versatz in Bogenkoordinaten. */
+function idcSpreadPageOffsets(spread) {
+  var out = [], i, page, x = 0, size;
+  for (i = 0; i < spread.pages.length; i++) {
+    page = spread.pages.item(i);
+    size = IDC.pageSize(page);
+    out.push({ page: page, offset: x, width: size.width, height: size.height });
+    x += size.width;
+  }
+  return out;
+}
+
+/*
+ * Hilfslinien eines Bogens. Laeuft unter Bogen-Nullpunkt (location ist
+ * dann bogenrelativ). Seitenzuordnung: fitToPage-Linien kommen ueber
+ * page.guides; bei Bogenlinien gilt die Seite, unter der eine senkrechte
+ * Linie steht; eine waagerechte Linie auf einem mehrseitigen Bogen hat keine.
+ */
+function idcCollectGuides(spread, isParent, out) {
+  var pages = idcSpreadPageOffsets(spread);
+  var i, j, guide, entry, orientation, location, pageHit, byPage = {};
+  for (j = 0; j < pages.length; j++) {
+    try {
+      for (i = 0; i < pages[j].page.guides.length; i++) {
+        byPage[String(Number(pages[j].page.guides.item(i).id))] = j;
+      }
+    } catch (e) { /* keine Seitenlinien */ }
+  }
+  for (i = 0; i < spread.guides.length; i++) {
+    guide = spread.guides.item(i);
+    orientation = idcGuideOrientation(guide);
+    location = IDC.round(Number(guide.location));
+    pageHit = null;
+    var fit = false;
+    try { fit = guide.fitToPage === true; } catch (e1) { fit = false; }
+    if (IDC.hasOwn(byPage, String(Number(guide.id))) && fit) {
+      pageHit = pages[byPage[String(Number(guide.id))]];
+    } else if (orientation === 'vertical') {
+      for (j = 0; j < pages.length; j++) {
+        if (location >= pages[j].offset - 0.005 && location <= pages[j].offset + pages[j].width + 0.005) {
+          pageHit = pages[j];
+          if (location < pages[j].offset + pages[j].width - 0.005) { break; }
+        }
+      }
+    } else if (pages.length === 1) {
+      pageHit = pages[0];
+    }
+    entry = {
+      guide_id: Number(guide.id),
+      orientation: orientation,
+      spread_index: IDC.spreadIndex(spread),
+      is_parent_spread: isParent,
+      page_id: pageHit === null ? null : Number(pageHit.page.id),
+      page_name: pageHit === null ? null : String(pageHit.page.name),
+      position_spread_mm: location,
+      position_page_mm: pageHit === null ? null : (orientation === 'vertical' ? IDC.round(location - pageHit.offset) : location),
+      fit_to_page: fit,
+      locked: false,
+      layer: null,
+      color: null
+    };
+    try { entry.locked = guide.locked === true; } catch (e2) { entry.locked = false; }
+    try { entry.layer = String(guide.itemLayer.name); } catch (e3) { entry.layer = null; }
+    try { entry.color = idcGuideColorName(guide.guideColor); } catch (e4) { entry.color = null; }
+    out.push(entry);
+  }
+}
+
+function idcAllGuides(doc, includeParents) {
+  var out = [], i;
+  for (i = 0; i < doc.spreads.length; i++) { idcCollectGuides(doc.spreads.item(i), false, out); }
+  if (includeParents) {
+    for (i = 0; i < doc.masterSpreads.length; i++) { idcCollectGuides(doc.masterSpreads.item(i), true, out); }
+  }
+  return out;
+}
+
+function idcGuidesLockedGlobally(doc) {
+  try { return doc.guidePreferences.guidesLocked === true; } catch (e) { return null; }
+}
+
+function idcCountGuides(doc) {
+  var all = idcAllGuides(doc, true);
+  var i, docCount = 0, parentCount = 0;
+  for (i = 0; i < all.length; i++) {
+    if (all[i].is_parent_spread) { parentCount += 1; } else { docCount += 1; }
+  }
+  return { document: docCount, parent: parentCount };
+}
+
+IDC.register('list_guides', { needs_document: true, read_only: true, ruler: 'spread' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var includeParents = args.include_parent_pages === false ? false : true;
+    var guides = idcAllGuides(doc, includeParents);
+    var counts = idcCountGuides(doc);
+    return {
+      guides: guides,
+      count: guides.length,
+      guides_locked_globally: idcGuidesLockedGlobally(doc),
+      count_document: counts.document,
+      count_parent: counts.parent,
+      include_parent_pages: includeParents
+    };
+  });
+
+/* Hilfslinienobjekt zu einer ID, sonst null. */
+function idcGuideById(doc, id, includeParents) {
+  var i, spread, guide;
+  var wanted = Number(id);
+  function look(s, isParent) {
+    var g;
+    try {
+      g = s.guides.itemByID(wanted);
+      if (g && g.isValid === true) { return { guide: g, spread: s, is_parent: isParent }; }
+    } catch (e) { /* nicht hier */ }
+    return null;
+  }
+  for (i = 0; i < doc.spreads.length; i++) {
+    guide = look(doc.spreads.item(i), false);
+    if (guide !== null) { return guide; }
+  }
+  if (includeParents) {
+    for (i = 0; i < doc.masterSpreads.length; i++) {
+      spread = doc.masterSpreads.item(i);
+      guide = look(spread, true);
+      if (guide !== null) { return guide; }
+    }
+  }
+  return null;
+}
+
+IDC.register('delete_guides', { needs_document: true, read_only: false, ruler: 'spread' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var includeParents = args.include_parent_pages === false ? false : true;
+    var modes = 0;
+    var targets = [];
+    var i, j, found, entry, all, spreadsWanted = {}, pages, deleted = [], failed = [], ids = [];
+
+    if (args.guide_ids !== undefined && args.guide_ids !== null) { modes += 1; }
+    if (args.page_ids !== undefined && args.page_ids !== null) { modes += 1; }
+    if (args.confirm_all === true) { modes += 1; }
+    if (modes !== 1) {
+      IDC.fail('invalid_argument', 'Pass exactly one of guide_ids[], page_ids[] or confirm_all: true.', null);
+    }
+
+    if (args.guide_ids !== undefined && args.guide_ids !== null) {
+      if (!IDC.isArray(args.guide_ids) || args.guide_ids.length === 0) {
+        IDC.fail('invalid_argument', 'guide_ids must be a non-empty array.', null);
+      }
+      for (i = 0; i < args.guide_ids.length; i++) {
+        found = idcGuideById(doc, args.guide_ids[i], includeParents);
+        if (found === null) {
+          failed.push({ guide_id: Number(args.guide_ids[i]), reason: 'not found' + (includeParents ? '' : ' (master spreads excluded)') });
+        } else {
+          targets.push(found);
+        }
+      }
+    } else {
+      if (args.page_ids !== undefined && args.page_ids !== null) {
+        pages = idcSelectPages(doc, args, includeParents);
+        for (i = 0; i < pages.length; i++) {
+          spreadsWanted[String(Number(pages[i].page.parent.id))] = true;
+        }
+      }
+      for (i = 0; i < doc.spreads.length; i++) {
+        if (args.confirm_all === true || spreadsWanted[String(Number(doc.spreads.item(i).id))]) {
+          for (j = 0; j < doc.spreads.item(i).guides.length; j++) {
+            targets.push({ guide: doc.spreads.item(i).guides.item(j), spread: doc.spreads.item(i), is_parent: false });
+          }
+        }
+      }
+      if (includeParents) {
+        for (i = 0; i < doc.masterSpreads.length; i++) {
+          if (args.confirm_all === true || spreadsWanted[String(Number(doc.masterSpreads.item(i).id))]) {
+            for (j = 0; j < doc.masterSpreads.item(i).guides.length; j++) {
+              targets.push({ guide: doc.masterSpreads.item(i).guides.item(j), spread: doc.masterSpreads.item(i), is_parent: true });
+            }
+          }
+        }
+      }
+    }
+
+    /* Beschreibung vor dem Loeschen festhalten */
+    all = idcAllGuides(doc, true);
+    var byId = {};
+    for (i = 0; i < all.length; i++) { byId[String(all[i].guide_id)] = all[i]; }
+
+    var prevGlobal = null, globalSet = false;
+    try {
+      prevGlobal = doc.guidePreferences.guidesLocked;
+      if (prevGlobal === true) { doc.guidePreferences.guidesLocked = false; globalSet = true; }
+    } catch (eg) { globalSet = false; }
+
+    try {
+      for (i = 0; i < targets.length; i++) {
+        var guide = targets[i].guide;
+        var gid = Number(guide.id);
+        entry = byId[String(gid)] || { guide_id: gid, orientation: null, position_spread_mm: null, position_page_mm: null, page_name: null };
+        var layer = null, layerWasLocked = false;
+        try {
+          layer = guide.itemLayer;
+          if (layer && layer.locked === true) { layer.locked = false; layerWasLocked = true; }
+        } catch (el) { layer = null; }
+        try {
+          try { if (guide.locked === true) { guide.locked = false; } } catch (eu) { /* egal */ }
+          guide.remove();
+          deleted.push({
+            guide_id: gid,
+            orientation: entry.orientation,
+            position: entry.position_page_mm !== null ? entry.position_page_mm : entry.position_spread_mm,
+            position_spread_mm: entry.position_spread_mm,
+            position_page_mm: entry.position_page_mm,
+            page: entry.page_name,
+            is_parent_spread: targets[i].is_parent
+          });
+          ids.push(gid);
+        } catch (er) {
+          failed.push({ guide_id: gid, reason: String(er.message ? er.message : er) });
+        } finally {
+          if (layer !== null && layerWasLocked) { try { layer.locked = true; } catch (el2) { /* egal */ } }
+        }
+      }
+    } finally {
+      if (globalSet) { try { doc.guidePreferences.guidesLocked = prevGlobal; } catch (eg2) { /* egal */ } }
+    }
+
+    var counts = idcCountGuides(doc);
+    if (targets.length === 0 && failed.length === 0) {
+      ctx.warn('No guides matched the selection; nothing was deleted.');
+    }
+    ctx.changes = { removed_guide_ids: ids };
+    return {
+      deleted: deleted,
+      deleted_count: deleted.length,
+      failed: failed,
+      remaining_document: counts.document,
+      remaining_parent: counts.parent
+    };
+  });