Skip to content

armgit / SOMA

Public Imported from GitHub
0

Desktop app for designing parametric 3D models in CadQuery together with the coding agent of your choice

App: Dokument „Drawings“ mit Verknüpfung zu 3D und Export (E97)

Kai-Jungsthoefel8ab96c48bc0d
diff --git a/app/package.json b/app/package.json
index af1f209..87d0823 100644
--- a/app/package.json
+++ b/app/package.json
@@ -22,6 +22,7 @@
"test:params": "npm run build && node test/params.mjs",
"test:fasteners": "npm run build && node test/fasteners.mjs",
"test:drawing": "npm run build && node test/drawing.mjs",
+ "test:drawview": "npm run build && node test/drawview.mjs",
"test:dxf": "npm run build && node test/dxf.mjs",
"test:animation": "npm run build && node test/animation.mjs",
"test:packages": "npm run build && node test/packages.mjs",
diff --git a/app/resources/help/code.png b/app/resources/help/code.png
index 0c23bce..a248efc 100644
Binary files a/app/resources/help/code.png and b/app/resources/help/code.png differ
diff --git a/app/resources/help/export.png b/app/resources/help/export.png
index 26f062f..78494bf 100644
Binary files a/app/resources/help/export.png and b/app/resources/help/export.png differ
diff --git a/app/resources/help/history.png b/app/resources/help/history.png
index 1037a88..a482f1b 100644
Binary files a/app/resources/help/history.png and b/app/resources/help/history.png differ
diff --git a/app/resources/help/markup.png b/app/resources/help/markup.png
index 0bc2284..309552f 100644
Binary files a/app/resources/help/markup.png and b/app/resources/help/markup.png differ
diff --git a/app/resources/help/settings.png b/app/resources/help/settings.png
index b7d7eeb..bb136ff 100644
Binary files a/app/resources/help/settings.png and b/app/resources/help/settings.png differ
diff --git a/app/resources/help/sidebar.png b/app/resources/help/sidebar.png
index 217e30b..88e2da2 100644
Binary files a/app/resources/help/sidebar.png and b/app/resources/help/sidebar.png differ
diff --git a/app/resources/help/start.png b/app/resources/help/start.png
index 96e8539..2fd7927 100644
Binary files a/app/resources/help/start.png and b/app/resources/help/start.png differ
diff --git a/app/resources/help/tools.png b/app/resources/help/tools.png
index 97a3a9c..ec42044 100644
Binary files a/app/resources/help/tools.png and b/app/resources/help/tools.png differ
diff --git a/app/resources/help/viewer.png b/app/resources/help/viewer.png
index 0f3f21a..aca5945 100644
Binary files a/app/resources/help/viewer.png and b/app/resources/help/viewer.png differ
diff --git a/app/resources/help/window.png b/app/resources/help/window.png
index be872ed..52b1def 100644
Binary files a/app/resources/help/window.png and b/app/resources/help/window.png differ
diff --git a/app/resources/skills/soma-app.md b/app/resources/skills/soma-app.md
index c5d68c0..011e3ce 100644
--- a/app/resources/skills/soma-app.md
+++ b/app/resources/skills/soma-app.md
@@ -123,11 +123,21 @@ Mark up is the quickest way to show the agent what you mean: draw an arrow, writ
2. **Files**: all files of the model. Click one to open it next to it.
3. **Analysis**: results the agent calculated, such as strength (FEM), wall thickness, overhang or clearance. Click one to see it in color on the model, with its report.
4. **Animation**: motion the agent made, for example an assembly sequence. Click one to play it in the viewer, "Make video" writes an MP4.
-5. **Skills**: rule sets for the agent, such as 3D printing, CNC or tolerances. Off, On demand (the agent reads them when the topic comes up) or Always.
-6. **Help**: this guide (F1).
-7. **Settings**: see below.
+5. **Drawings**: all technical drawings of the model in one view, next to the viewer (no sidebar). See "Drawings" below.
+6. **Skills**: rule sets for the agent, such as 3D printing, CNC or tolerances. Off, On demand (the agent reads them when the topic comes up) or Always.
+7. **Help**: this guide (F1).
+8. **Settings**: see below.
+
+A dot on Analysis, Animation or Drawings means the agent made something new you have not looked at yet.
+
+## Drawings
+
+Ask the agent for a technical drawing ("Make a drawing of the bracket with all dimensions"). It writes `drawings/*.py` and builds the sheets with `soma drawing build`. "Drawings" on the left shows all sheets one after another in the code column; click it again to close the column.
-A dot on Analysis or Animation means the agent made something new you have not looked at yet.
+- Above each sheet: size, scale, number of views and dimensions, "older than the code" when the model changed since, and the warnings of the check (click to list them, click a warning to open its line). The buttons open the drawing's code or the DXF, build the sheet again or send it to the agent.
+- Point at a view or a dimension on the sheet to highlight it. Click it to see it on the model: a view turns the camera to its direction, a section sets the section tool to the same plane, a detail zooms in, a dimension shows its points and value. The card below has "Code" and "Send to agent". Escape clears it.
+- The bar of the viewer switches between all pages and single pages, shows page previews on the left and fits the page width or the whole page. Select text and click "Quote to agent" to send it with its page.
+- "Export" at the top saves all sheets as one PDF, or each sheet as PDF, DXF or both into a folder. The export button above a sheet saves just that sheet.
## Files and code
diff --git a/app/src/main/drawings.ts b/app/src/main/drawings.ts
new file mode 100644
index 0000000..14cc9a5
--- /dev/null
+++ b/app/src/main/drawings.ts
@@ -0,0 +1,140 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { DrawingBuildResult, DrawingDim, DrawingEntry, DrawingFileError, DrawingList, DrawingView, DrawingWarning } from '../shared/types';
+import { newestSourceMtime, runSoma } from './build';
+import { resolveInside } from './files';
+
+// Technische Zeichnungen (E76) für das Dokument „Drawings“. Gebaut wird in Python (`soma drawing build`), die App liest nur
+// .soma/drawings/index.json. Der Index kommt aus dem Projekt, also wird jedes Feld geprüft, bevor es zum Renderer geht.
+
+const mtime = (f: string) => { try { return fs.statSync(f).mtimeMs; } catch { return 0; } };
+const num = (v: unknown): number | null => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+const str = (v: unknown, max = 400): string | null => (typeof v === 'string' ? v.slice(0, max) : null);
+/** Zahlenliste fester Länge (Punkte, Richtungen, Rechtecke), sonst undefined. */
+const vec = (v: unknown, n: number): number[] | undefined =>
+ Array.isArray(v) && v.length === n && v.every((x) => num(x) !== null) ? (v as number[]).map(Number) : undefined;
+const line = (v: unknown) => (typeof v === 'number' && Number.isInteger(v) && v > 0 ? v : null);
+
+function view(raw: unknown): DrawingView | null {
+ const v = raw as Record<string, unknown>;
+ const name = str(v?.name, 200), bbox = vec(v?.bbox, 4), direction = vec(v?.direction, 3);
+ if (!name || !bbox || !direction) return null;
+ const out: DrawingView = { name, kind: str(v.kind, 40) ?? 'view', scale: str(v.scale, 40) ?? '', line: line(v.line), file: str(v.file), direction, bbox };
+ if (Array.isArray(v.parts)) out.parts = v.parts.filter((p): p is string => typeof p === 'string').slice(0, 500);
+ out.right = vec(v.right, 3);
+ out.up = vec(v.up, 3);
+ out.center = vec(v.center, 3);
+ out.size = num(v.size) ?? undefined;
+ const s = v.section as Record<string, unknown> | undefined;
+ if (s && typeof s === 'object') out.section = { kind: str(s.kind, 40) ?? '', point: vec(s.point, 3), normal: vec(s.normal, 3) };
+ const d = v.detail as Record<string, unknown> | undefined;
+ const dc = vec(d?.center, 3), dr = num(d?.radius);
+ if (dc && dr) out.detail = { center: dc, radius: dr, parent: str(d!.parent, 200) ?? '' };
+ return out;
+}
+
+function dim(raw: unknown): DrawingDim | null {
+ const d = raw as Record<string, unknown>;
+ const value = num(d?.value), viewName = str(d?.view, 200);
+ if (value === null || !viewName) return null;
+ const points = Array.isArray(d.points) ? d.points.map((p) => vec(p, 3)).filter((p): p is number[] => !!p) : undefined;
+ return {
+ // soma setzt die Beschriftung für den Agenten in Anführungszeichen ("4x Ø8"), auf dem Blatt stehen keine
+ kind: str(d.kind, 40) ?? 'linear', value, label: (str(d.label, 200) ?? str(d.text, 200) ?? String(value)).replace(/^"(.*)"$/s, '$1'), view: viewName,
+ line: line(d.line), file: str(d.file), points: points?.length ? points : undefined, radius: num(d.radius),
+ box: vec(d.box, 4), textBox: vec(d.text_box, 4),
+ };
+}
+
+function warning(raw: unknown): DrawingWarning | null {
+ const w = raw as Record<string, unknown>;
+ const message = str(w?.message, 2000);
+ return message ? { message, file: str(w.file), line: line(w.line), box: vec(w.box, 4) } : null;
+}
+
+/** Liste aus .soma/drawings/index.json. Veraltet: Modell oder Zeichnungsdatei neuer als die PDF. */
+export function readDrawingList(dir: string, building = false): DrawingList {
+ let idx: { version?: unknown; drawings?: unknown[]; errors?: unknown[] } = {};
+ try { idx = JSON.parse(fs.readFileSync(path.join(dir, '.soma', 'drawings', 'index.json'), 'utf8')); } catch { /* noch nichts gebaut */ }
+ const model = newestSourceMtime(dir);
+ const drawings: DrawingEntry[] = [];
+ for (const raw of Array.isArray(idx.drawings) ? idx.drawings : []) {
+ const e = raw as Record<string, unknown>;
+ const id = str(e.id, 200), name = str(e.name, 200), pdf = str(e.pdf), width = num(e.width), height = num(e.height);
+ if (!id || !name || !pdf || !width || !height || width <= 0 || height <= 0) continue;
+ // Nur PDFs, die soma selbst ablegt: output/drawings/<id>.pdf
+ if (!/^output\/drawings\/[^/]+\.pdf$/i.test(pdf)) continue;
+ let pdfAbs: string, src: string | null = null;
+ try { pdfAbs = resolveInside(dir, pdf); } catch { continue; }
+ const file = str(e.file);
+ if (file) try { src = resolveInside(dir, file); } catch { src = null; }
+ const built = mtime(pdfAbs);
+ if (!built) continue;
+ const dxf = str(e.dxf);
+ drawings.push({
+ id, name, file: file && src ? file : null, line: line(e.line), size: str(e.size, 40) ?? '', width, height, scale: str(e.scale, 40) ?? '',
+ pdf, dxf: dxf && /^output\/drawings\/[^/]+\.dxf$/i.test(dxf) ? dxf : null,
+ pageBox: vec(e.page_box, 4) ?? [0, 0, width, height],
+ views: (Array.isArray(e.views) ? e.views : []).map(view).filter((x): x is DrawingView => !!x),
+ dims: (Array.isArray(e.dims) ? e.dims : []).map(dim).filter((x): x is DrawingDim => !!x),
+ warnings: (Array.isArray(e.warnings) ? e.warnings : []).map(warning).filter((x): x is DrawingWarning => !!x),
+ built, stale: Math.max(model, src ? mtime(src) : 0) > built, linked: Number(idx.version) >= 2,
+ });
+ }
+ // Fehler gelöschter Dateien gelten nicht mehr (der Index wird erst beim nächsten Bauen bereinigt)
+ const exists = (rel: string) => { try { return fs.existsSync(resolveInside(dir, rel)); } catch { return false; } };
+ const errors: DrawingFileError[] = (Array.isArray(idx.errors) ? idx.errors : []).map((x) => x as Record<string, unknown>)
+ .filter((x) => typeof x.file === 'string' && typeof x.message === 'string' && exists(x.file))
+ .map((x) => ({ file: x.file as string, line: line(x.line), message: (x.message as string).slice(0, 4000) }));
+ return { drawings, errors, building };
+}
+
+/** Eine Zeichnungsdatei (drawings/x.py)? Nur solche baut die App einzeln. */
+export const isDrawingFile = (rel: string) => /^drawings\/[^/]+\.py$/i.test(rel.replace(/\\/g, '/'));
+
+/**
+ * Baut Zeichnungen auf Wunsch im Hintergrund, einen Lauf nach dem anderen. Kommt während eines Laufs ein weiterer Wunsch,
+ * folgt genau ein weiterer (für alle, wenn einer alle wollte), wie bei den Animationen.
+ */
+export class DrawingBuilder {
+ private running: Promise<DrawingBuildResult> | null = null;
+ private pending: Set<string> | 'all' | null = null;
+ private disposed = false;
+
+ constructor(private readonly dir: string, private readonly changed: () => void) {}
+
+ get busy(): boolean { return this.running !== null; }
+
+ request(file: string | null): Promise<DrawingBuildResult> {
+ if (this.running) {
+ if (file === null || this.pending === 'all') this.pending = 'all';
+ else { const p = this.pending ?? new Set<string>(); p.add(file); this.pending = p; }
+ return this.running.then(() => this.running ?? Promise.resolve({ ...readDrawingList(this.dir), ok: true }));
+ }
+ this.running = this.run(file === null ? null : [file]);
+ return this.running;
+ }
+
+ private async run(files: string[] | null): Promise<DrawingBuildResult> {
+ this.changed();
+ let res: DrawingBuildResult;
+ try {
+ const errors: string[] = [];
+ for (const f of files ?? [null]) {
+ // Fehler einzelner Zeichnungen stehen im Index. Ohne JSON-Antwort ging gar nichts (etwa: das Modell baut nicht).
+ const r = await runSoma(['drawing', 'build', ...(f ? [f] : []), '--project', this.dir, '--json'], this.dir, 10 * 60 * 1000);
+ if (!r.out.trim().startsWith('{')) errors.push((r.err || r.out).trim().split(/\r?\n/).slice(-3).join('\n') || 'soma drawing build returned no result');
+ }
+ res = { ...readDrawingList(this.dir), ok: errors.length === 0, ...(errors.length ? { error: errors.join('\n') } : {}) };
+ } catch (e) {
+ res = { ...readDrawingList(this.dir), ok: false, error: e instanceof Error ? e.message : String(e) };
+ }
+ const next = this.pending;
+ this.pending = null;
+ this.running = next && !this.disposed ? this.run(next === 'all' ? null : [...next]) : null;
+ if (!this.running) this.changed();
+ return res;
+ }
+
+ dispose(): void { this.disposed = true; this.pending = null; }
+}
diff --git a/app/src/main/main.ts b/app/src/main/main.ts
index ddb9f4b..8b37b0a 100644
--- a/app/src/main/main.ts
+++ b/app/src/main/main.ts
@@ -259,6 +259,9 @@ function registerIpc(ctl: ProjectController): void {
ipcMain.handle('anim:list', () => ctl.animList());
ipcMain.handle('anim:build', (_e, file: unknown) => ctl.animBuild(file));
+ ipcMain.handle('drawings:list', () => ctl.drawingList());
+ ipcMain.handle('drawings:build', (_e, file: unknown) => ctl.drawingBuild(file));
+ ipcMain.handle('drawings:export', (_e, what: unknown, sheet: unknown) => ctl.drawingExport(what, sheet));
ipcMain.handle('results:list', () => ctl.results());
ipcMain.handle('results:rerun', (_e, id: unknown) => ctl.rerunResult(id));
ipcMain.handle('render:video', (_e, id: unknown) => ctl.renderVideo(id));
diff --git a/app/src/main/projects.ts b/app/src/main/projects.ts
index eae440d..6f3f0be 100644
--- a/app/src/main/projects.ts
+++ b/app/src/main/projects.ts
@@ -3,11 +3,13 @@ import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import type {
- AnimBuildResult, AnimList, ExportResult, GitLog, MeasureEntity, MeasurePrepared, MeasureRequest, MeasureResponse, ModelMap, OpenResult, PreviewResult,
+ AnimBuildResult, AnimList, DrawingBuildResult, DrawingList, ExportResult, GitLog, MeasureEntity, MeasurePrepared, MeasureRequest, MeasureResponse, ModelMap, OpenResult, PreviewResult,
ParamResult, ParamState, ParamValue, ProjectInfo, RemoveResult, RenderResult, RestoreResult, ResultEntry, SaveResult, SaveState, SkillInfo, SkillResult,
} from '../shared/types';
import { affectsAnimation } from '../shared/editable';
import { AnimBuilder, listResults, readAnimList, rerunResult, samePath } from './animations';
+import { DrawingBuilder, isDrawingFile, readDrawingList } from './drawings';
+import { resolveInside } from './files';
import { BuildManager, buildIsStale, currentBuild, newestSourceMtime, runSoma } from './build';
import { checkRequest, RenderService, type RenderRequest } from './render';
import { choose, chooseExportTarget, choosePath, documentsDir, trashItem } from './dialogs';
@@ -40,6 +42,8 @@ interface Session {
measure: MeasureService;
/** Animationen bauen (E58), ausgelöst vom Watcher, der Oberfläche oder vor einem Video. */
anims: AnimBuilder;
+ /** Zeichnungen bauen (E76), nur auf Wunsch aus dem Dokument „Drawings“. */
+ drawings: DrawingBuilder;
animTimer?: NodeJS.Timeout;
stopWatch: () => void;
poll: NodeJS.Timeout;
@@ -89,6 +93,7 @@ export class ProjectController {
clearTimeout(s.animTimer);
s.stopWatch();
s.anims.dispose();
+ s.drawings.dispose();
s.builds.dispose();
s.terminals.killAll();
s.measure.stop();
@@ -121,12 +126,13 @@ export class ProjectController {
void git.ensureIgnored(); // ältere Projekte: Zwischenergebnisse auch aus den Commits des Agenten heraushalten
syncHelpImages(dir, helpDir()); // Bilder der Anleitung (E83) fehlen nach dem Öffnen einer .soma-Datei oder sind von einer älteren App
const anims = new AnimBuilder(dir, () => this.send('anim:changed'));
+ const drawings = new DrawingBuilder(dir, () => this.send('drawings:changed'));
const stopWatch = watchProject(dir, (rel) => builds.sourceChanged(rel ? path.join(dir, rel) : null), () => this.send('fs:changed'),
- (rel) => this.animFileChanged(rel), () => builds.externalResult());
+ (rel) => this.animFileChanged(rel), () => builds.externalResult(), () => this.send('drawings:changed'));
// Projektumgebung (E67): Meist steht sie schon, sonst legt `soma env` sie in rund 0,5 s an. Die Terminals kennen ihre
// Pfade vorab, gewartet wird nur vor dem Installieren von Paketen
const env = envIsCurrent(dir) ? Promise.resolve(null) : ensureEnv(dir);
- const session: Session = { id, dir, builds, terminals, git, measure: new MeasureService(dir), anims, stopWatch, signature: '', env, poll: setInterval(() => void this.pollGit(), POLL_MS) };
+ const session: Session = { id, dir, builds, terminals, git, measure: new MeasureService(dir), anims, drawings, stopWatch, signature: '', env, poll: setInterval(() => void this.pollGit(), POLL_MS) };
this.session = session;
void env.then((err) => { if (err) { console.error('[soma]', err); builds.reportPackageError(err); } });
builds.on('status', (st) => {
@@ -583,6 +589,97 @@ export class ProjectController {
}, 700);
}
+ drawingList(): DrawingList {
+ const s = this.need();
+ return readDrawingList(s.dir, s.drawings.busy);
+ }
+
+ /**
+ * Zeichnungen exportieren (E97): `set` alle Blätter als eine PDF (output/drawings.pdf von soma), `pdf`/`dxf`/`both` je
+ * Blatt eine Datei in einen gewählten Ordner, mit `sheet` nur dieses Blatt in eine gewählte Datei. Kopiert werden die
+ * Dateien, die soma gebaut hat. Vorhandene Dateien ersetzt die App nur nach Rückfrage (beim Einzelexport fragt der Dialog).
+ */
+ async drawingExport(what: unknown, sheet: unknown): Promise<ExportResult> {
+ const s = this.need();
+ const kind = String(what);
+ if (!['set', 'pdf', 'dxf', 'both'].includes(kind)) return { ok: false, files: [], error: `Unknown export: ${kind}` };
+ const list = readDrawingList(s.dir, s.drawings.busy);
+ if (list.building) return { ok: false, files: [], error: 'The drawings are being built. Export when the build is done.' };
+ const one = sheet == null ? null : list.drawings.find((d) => d.id === String(sheet)) ?? null;
+ if (sheet != null && !one) return { ok: false, files: [], error: 'This sheet does not exist any more. Rebuild the drawings.' };
+ const sheets = one ? [one] : list.drawings;
+ if (!sheets.length) return { ok: false, files: [], error: 'There are no drawings to export.' };
+ const abs = (rel: string) => resolveInside(s.dir, rel);
+ const warnings: string[] = [];
+ const stale = sheets.filter((d) => d.stale).map((d) => d.name);
+ if (stale.length) warnings.push(`Older than the code: ${stale.join(', ')}. Rebuild to export the current state.`);
+ const last = getAppState(s.id).exportDir;
+ const startDir = last && fs.existsSync(last) ? last : documentsDir();
+ // Eine Datei: ein Blatt als PDF oder DXF, oder alle Blätter in einer PDF
+ if (kind === 'set' || (one && kind !== 'both')) {
+ let src: string, name: string;
+ const ext = kind === 'dxf' ? 'dxf' : 'pdf';
+ if (kind === 'set') {
+ src = abs('output/drawings.pdf');
+ // Die Sammel-PDF schreibt soma nur ohne Fehler, und nur ein Lauf über alle Blätter macht sie so neu wie jedes Blatt
+ if (list.errors.length) return { ok: false, files: [], error: 'A drawing has errors, so output/drawings.pdf is not up to date. Fix them or export each sheet as PDF.' };
+ const setTime = fs.existsSync(src) ? fs.statSync(src).mtimeMs : 0;
+ if (!setTime || list.drawings.some((d) => d.built > setTime + 2000)) return { ok: false, files: [], error: 'output/drawings.pdf is older than some sheets. Use “Rebuild all” first.' };
+ name = `${safeFileName(readProjectJson(s.id)?.name ?? 'Model')} drawings.pdf`;
+ } else {
+ const rel = ext === 'pdf' ? one!.pdf : one!.dxf;
+ if (!rel) return { ok: false, files: [], error: `“${one!.name}” has no ${ext.toUpperCase()}.` };
+ src = abs(rel);
+ name = `${safeFileName(one!.name)}.${ext}`;
+ }
+ if (!fs.existsSync(src)) return { ok: false, files: [], error: `${path.basename(src)} is missing. Rebuild the drawings.` };
+ const target = await chooseExportTarget(this.getWin(), { kind: 'file', title: kind === 'set' ? 'Export all sheets as one PDF' : `Export “${one!.name}”`,
+ defaultPath: path.join(startDir, name), ext, label: ext.toUpperCase() });
+ if (!target) return { ok: false, files: [], cancelled: true };
+ const dest = path.extname(target) ? target : `${target}.${ext}`;
+ try { fs.copyFileSync(src, dest); } catch (e) { return { ok: false, files: [], error: `Export failed: ${e instanceof Error ? e.message : String(e)}` }; }
+ patchAppState(s.id, { exportDir: path.dirname(dest) });
+ return { ok: true, files: [dest], target: dest, warnings };
+ }
+ // Ordner: je Blatt PDF, DXF oder beides
+ const target = await chooseExportTarget(this.getWin(), { kind: 'dir', title: 'Choose a folder for the drawings', defaultPath: startDir });
+ if (!target) return { ok: false, files: [], cancelled: true };
+ const plan: [string, string][] = [];
+ const missing: string[] = [];
+ for (const d of sheets) {
+ for (const [ext, rel] of [['pdf', d.pdf], ['dxf', d.dxf]] as const) {
+ if (kind !== 'both' && kind !== ext) continue;
+ const src = rel ? abs(rel) : null;
+ if (!src || !fs.existsSync(src)) { missing.push(`${d.name} (${ext.toUpperCase()})`); continue; }
+ plan.push([src, path.join(target, `${safeFileName(d.name)}.${ext}`)]);
+ }
+ }
+ if (missing.length) warnings.push(`Missing: ${missing.join(', ')}.`);
+ if (!plan.length) return { ok: false, files: [], error: 'There is no file to export. Rebuild the drawings.', warnings };
+ const exists = plan.filter(([, d]) => fs.existsSync(d)).map(([, d]) => path.basename(d));
+ if (exists.length) {
+ const c = await choose(this.getWin(), {
+ title: 'Export', message: exists.length === 1 ? 'This file already exists in the folder:' : `These ${exists.length} files already exist in the folder:`,
+ detail: `${exists.slice(0, 10).join('\n')}${exists.length > 10 ? `\n… and ${exists.length - 10} more` : ''}`, buttons: ['Replace', 'Cancel'],
+ });
+ if (c !== 0) return { ok: false, files: [], cancelled: true };
+ }
+ try {
+ fs.mkdirSync(target, { recursive: true });
+ for (const [src, dest] of plan) fs.copyFileSync(src, dest);
+ } catch (e) { return { ok: false, files: [], error: `Export failed: ${e instanceof Error ? e.message : String(e)}` }; }
+ patchAppState(s.id, { exportDir: target });
+ return { ok: true, files: plan.map(([, d]) => d), target, warnings };
+ }
+
+ /** Zeichnungen bauen: eine Datei (drawings/x.py) oder alle. */
+ drawingBuild(file: unknown): Promise<DrawingBuildResult> {
+ const s = this.need();
+ const f = file == null ? null : String(file).replace(/\\/g, '/');
+ if (f !== null && !isDrawingFile(f)) return Promise.resolve({ ...readDrawingList(s.dir), ok: false, error: 'Not a drawing file (drawings/*.py).' });
+ return s.drawings.request(f);
+ }
+
results(): ResultEntry[] { return listResults(this.need().dir); }
rerunResult(id: unknown): Promise<{ ok: boolean; error?: string }> {
diff --git a/app/src/main/watcher.ts b/app/src/main/watcher.ts
index e69ff58..e675a75 100644
--- a/app/src/main/watcher.ts
+++ b/app/src/main/watcher.ts
@@ -10,22 +10,29 @@ const isShown = (rel: string) => /^\.soma[\\/](feedback|skills)([\\/]|$)/i.test(
const isIgnored = (rel: string) => IGNORED_TOP.has(topSegment(rel)) || rel.split(/[\\/]/).includes('__pycache__');
/** `soma build` schreibt build.json als Letztes, auch wenn der Agent im Terminal baut statt die App. */
const isBuildResult = (rel: string) => /^\.soma[\\/]build\.json$/i.test(rel);
+/** Zeichnungen (E76): neuer Index von `soma drawing build` (auch aus dem Terminal) oder eine geänderte Zeichnungsdatei. */
+const isDrawing = (rel: string) => /^\.soma[\\/]drawings[\\/]index\.json$/i.test(rel) || /^drawings[\\/][^\\/]+\.py$/i.test(rel);
/** Quelltext-Aenderung: dieselbe Regel wie beim Speichern im Editor (src/shared/editable.ts). */
const isSource = affectsBuild;
/**
* Beobachtet den Projektordner. `onSource` bei relevanten Aenderungen (fuer Auto-Build), `onFiles` fuer die Dateiliste,
- * `onAnim` bei Aenderungen an animations/*.py (E58), `onBuilt` bei einem neuen Build-Ergebnis. Gibt eine Funktion zum
- * Beenden zurueck. Fehler des Watchers werden verschluckt: ohne Watcher bleibt der Knopf.
+ * `onAnim` bei Aenderungen an animations/*.py (E58), `onBuilt` bei einem neuen Build-Ergebnis, `onDrawings` bei neuen
+ * Zeichnungen (entprellt). Gibt eine Funktion zum Beenden zurueck. Fehler des Watchers werden verschluckt: ohne Watcher bleibt der Knopf.
*/
export function watchProject(dir: string, onSource: (rel: string | null) => void, onFiles: () => void, onAnim: (rel: string) => void = () => {},
- onBuilt: () => void = () => {}): () => void {
+ onBuilt: () => void = () => {}, onDrawings: () => void = () => {}): () => void {
let filesTimer: NodeJS.Timeout | null = null;
+ let drawTimer: NodeJS.Timeout | null = null;
let watcher: fs.FSWatcher | null = null;
try {
watcher = fs.watch(dir, { recursive: true }, (_evt, filename) => {
const rel = filename ? String(filename) : '';
if (rel && isBuildResult(rel)) { onBuilt(); return; }
+ if (rel && isDrawing(rel)) {
+ if (drawTimer) clearTimeout(drawTimer);
+ drawTimer = setTimeout(onDrawings, 300);
+ }
if (rel && isIgnored(rel) && !isShown(rel)) return;
if (rel && affectsAnimation(rel)) onAnim(rel.replace(/\\/g, '/'));
else if (!rel || (isSource(rel) && !isShown(rel))) onSource(rel || null);
@@ -34,5 +41,5 @@ export function watchProject(dir: string, onSource: (rel: string | null) => void
});
watcher.on('error', () => { /* Projektordner weg oder gesperrt: nichts zu tun */ });
} catch { /* Watcher nicht verfuegbar */ }
- return () => { if (filesTimer) clearTimeout(filesTimer); watcher?.close(); };
+ return () => { if (filesTimer) clearTimeout(filesTimer); if (drawTimer) clearTimeout(drawTimer); watcher?.close(); };
}
diff --git a/app/src/preload/preload.ts b/app/src/preload/preload.ts
index 132c444..d665488 100644
--- a/app/src/preload/preload.ts
+++ b/app/src/preload/preload.ts
@@ -117,6 +117,12 @@ const api: SomaApi = {
build: (file) => ipcRenderer.invoke('anim:build', file ?? null),
onChanged: (cb) => { ipcRenderer.on('anim:changed', () => cb()); },
},
+ drawings: {
+ list: () => ipcRenderer.invoke('drawings:list'),
+ build: (file) => ipcRenderer.invoke('drawings:build', file ?? null),
+ export: (what, sheet) => ipcRenderer.invoke('drawings:export', what, sheet ?? null),
+ onChanged: (cb) => { ipcRenderer.on('drawings:changed', () => cb()); },
+ },
results: {
list: () => ipcRenderer.invoke('results:list'),
rerun: (id) => ipcRenderer.invoke('results:rerun', id),
diff --git a/app/src/renderer/code.ts b/app/src/renderer/code.ts
index 6dbeeb8..39fba9a 100644
--- a/app/src/renderer/code.ts
+++ b/app/src/renderer/code.ts
@@ -78,10 +78,24 @@ interface Doc {
pdf?: PdfView;
/** DXF-Reiter (E80): wie PDF, statt des Editors die DXF-Ansicht. */
dxf?: DxfView;
+ /** Reiter ohne Datei (etwa „Drawings“): eine eigene Ansicht mit Namen. Der Schlüssel beginnt mit `soma:`. */
+ pane?: Pane;
+ label?: string;
}
-/** Eigene Ansicht statt des Editors (PDF, DXF). */
-const paneOf = (d: Doc): PdfView | DxfView | undefined => d.pdf ?? d.dxf;
+/** Ansicht eines Reiters ohne Datei. `refresh` kommt bei Dateiänderungen wie bei PDF und DXF. */
+export interface Pane {
+ root: HTMLElement;
+ dispose(): void;
+ hidden(): void;
+ shown(): void;
+ refresh?(): void;
+}
+
+/** Eigene Ansicht statt des Editors (PDF, DXF, Reiter ohne Datei). */
+const paneOf = (d: Doc): Pane | undefined => d.pdf ?? d.dxf ?? d.pane;
+/** Schlüssel der Reiter ohne Datei, kann nie ein Pfad im Projekt sein. */
+export const isPaneKey = (key: string) => key.startsWith('soma:');
const isMarkdown = (file: string) => /\.md$/i.test(file);
export const isPdf = (file: string) => /\.pdf$/i.test(file);
@@ -233,6 +247,27 @@ export class CodePanel {
get activeFile(): string | null { return this.active; }
+ /** Reiter ohne Datei öffnen (oder nach vorne holen). `make` baut die Ansicht beim ersten Mal. */
+ openPane(key: string, label: string, make: () => Pane): void {
+ let d = this.docs.get(key);
+ if (!d) {
+ const pane = make();
+ pane.root.hidden = true;
+ this.ui.view.append(pane.root);
+ d = { file: key, label, pane, base: '', eol: '\n', locked: label, dirty: false, writing: false, queue: Promise.resolve(), conflict: null, mark: null, scrollTop: 0,
+ preview: false, previewScroll: 0, state: EditorState.create({ doc: '', extensions: [EditorState.readOnly.of(true)] }) };
+ this.docs.set(key, d);
+ }
+ this.activate(d);
+ this.renderChrome();
+ }
+
+ /** Ansicht eines offenen Reiters ohne Datei. */
+ pane(key: string): Pane | undefined { return this.docs.get(key)?.pane; }
+
+ /** Reiter schließen (ohne Rückfrage nur bei Reitern ohne Eingaben, wie Ansichten). */
+ closeTab(key: string): Promise<void> { return this.close(key); }
+
async open(file: string, mark?: Mark, scroll = true): Promise<void> {
const d = this.docs.get(file) ?? (await this.load(file));
if (!d) return;
@@ -255,6 +290,7 @@ export class CodePanel {
async refresh(): Promise<void> {
for (const d of [...this.docs.values()]) {
if (d.pdf) { await this.refreshPdf(d); continue; }
+ if (d.pane) { d.pane.refresh?.(); continue; }
// Nicht abwarten: Neu zeichnen dauert bei großen DXF Sekunden, die übrigen Reiter sollen nicht darauf warten
if (d.dxf) { void this.refreshDxf(d); continue; }
if (d.writing) continue;
@@ -591,12 +627,13 @@ export class CodePanel {
const { tabs, info, banner } = this.ui;
this.deps.active?.(this.active);
tabs.replaceChildren(...[...this.docs.values()].map((d) => {
- const x = el('button', { className: 'x', title: `Close ${d.file}` }, icon('x', 11, 2.2));
- x.setAttribute('aria-label', `Close ${d.file}`);
+ const x = el('button', { className: 'x', title: `Close ${d.label ?? d.file}` }, icon('x', 11, 2.2));
+ x.setAttribute('aria-label', `Close ${d.label ?? d.file}`);
x.addEventListener('click', (e) => { e.stopPropagation(); void this.close(d.file); });
const state = d.conflict ? el('span', { className: 'dirty warn', textContent: '●', title: 'Conflict with a change from outside' })
: d.dirty ? el('span', { className: 'dirty', textContent: '●', title: 'Not saved' }) : null;
- const tab = el('div', { className: 'ctab' + (d.file === this.active ? ' on' : ''), title: d.file }, el('span', { textContent: d.file.split('/').pop()! }), state, x);
+ const tab = el('div', { className: 'ctab' + (d.file === this.active ? ' on' : '') + (d.pane ? ' pane' : ''), title: d.label ?? d.file },
+ d.pane ? icon('drawing', 12, 1.9) : null, el('span', { textContent: d.label ?? d.file.split('/').pop()! }), state, x);
tab.addEventListener('click', () => { this.activate(d); this.renderChrome(); });
return tab;
}));
@@ -616,7 +653,7 @@ export class CodePanel {
const m = paneOf(d) ? null : d.mark;
const left: (Node | string)[] = [];
- if (paneOf(d)) { /* PDF und DXF: eigene Leiste in der Ansicht */ }
+ if (paneOf(d)) { /* PDF, DXF und Ansichten: eigene Leiste in der Ansicht */ }
else if (d.locked) left.push(icon('lock', 13, 2), `Read only. ${d.locked}`);
else if (m) {
const sw = m.kind === 'er' ? el('span', { className: 'ci-err' }, icon('alert', 13, 2)) : el('span', { className: 'sw' });
@@ -690,7 +727,7 @@ export class CodePanel {
const d = this.active ? this.docs.get(this.active) : undefined;
return {
file: this.active, files: [...this.docs.keys()], dirty: !!d?.dirty, conflict: d?.conflict ? (d.conflict.disk === null ? 'gone' : 'changed') : null,
- locked: d?.locked ?? null, readOnly: this.view.state.readOnly, preview: !this.md.hidden, pdf: d?.pdf?.state() ?? null, dxf: d?.dxf?.state() ?? null, line: this.view.state.doc.lineAt(this.view.state.selection.main.head).number,
+ locked: d?.locked ?? null, readOnly: this.view.state.readOnly, preview: !this.md.hidden, pdf: d?.pdf?.state() ?? null, dxf: d?.dxf?.state() ?? null, pane: d?.pane ? d.file : null, line: this.view.state.doc.lineAt(this.view.state.selection.main.head).number,
rendered: this.md.hidden ? null : [...this.md.querySelectorAll<HTMLElement>('.md > *, .md li')].map((x) => `${x.tagName.toLowerCase()}:${(x.textContent ?? '').trim().slice(0, 60)}`), text: this.text(), focused: this.view.hasFocus, unsaved: this.unsaved(),
marked: [...this.ui.view.querySelectorAll('.cm-line.cm-mark-hl, .cm-line.cm-mark-er')].map((x) => (x.classList.contains('cm-mark-er') ? 'er:' : 'hl:') + x.textContent),
};
diff --git a/app/src/renderer/drawings.ts b/app/src/renderer/drawings.ts
new file mode 100644
index 0000000..8781230
--- /dev/null
+++ b/app/src/renderer/drawings.ts
@@ -0,0 +1,480 @@
+import type { DrawingDim, DrawingEntry, DrawingList, DrawingView, DrawingWarning } from '../shared/types';
+import type { Pane } from './code';
+import { icon } from './icons';
+import { PdfView, type PdfDeps } from './pdfview';
+import { el, menuItem, menus } from './ui';
+
+// Dokument „Drawings“ (E76): alle Blätter aus .soma/drawings/index.json als ein PDF in der Code-Spalte, ohne Seitenleiste.
+// Über jedem Blatt ein Kopf mit Format, Stand, Warnungen und Knöpfen. Auf dem Blatt sind Ansichten und Maße anklickbar,
+// die Lage kommt aus dem Index (Blatt-mm), gezeigt wird in 3D über DrawingLink (drawlink.ts).
+
+export const DRAWINGS_KEY = 'soma:drawings';
+
+interface Link {
+ showView(e: DrawingEntry, v: DrawingView): string | null;
+ showDim(e: DrawingEntry, d: DrawingDim): string | null;
+ clear(): void;
+}
+interface Deps {
+ list(): Promise<DrawingList>;
+ build(file?: string): Promise<{ ok: boolean; error?: string }>;
+ readBinary(rel: string): Promise<ArrayBuffer>;
+ pdf: PdfDeps;
+ openCode(file: string, line: number | null, label: string): void;
+ openFile(rel: string): void;
+ insert(text: string): void;
+ toast(text: string, kind?: 'ok' | 'info' | 'error'): void;
+ link: Link;
+ /** Exportieren mit Dateidialog (Meldung macht der Aufrufer). */
+ exportFiles(what: 'set' | 'pdf' | 'dxf' | 'both', sheet?: string): Promise<void>;
+ /** Element für Aufklappmenüs. */
+ menu: HTMLElement;
+ /** Blatt neu (seit dem Öffnen des Modells gebaut und noch nicht angesehen)? */
+ isNew(e: DrawingEntry): boolean;
+ seen(e: DrawingEntry): void;
+ /** Liste neu gelesen (für den Punkt an der Leiste). */
+ listed(list: DrawingList): void;
+}
+
+type Hit = { kind: 'view'; v: DrawingView; box: number[] } | { kind: 'dim'; d: DrawingDim; box: number[] };
+const plural = (n: number, w: string) => `${n} ${w}${n === 1 ? '' : 's'}`;
+const area = (b: number[]) => Math.max(0, b[2] - b[0]) * Math.max(0, b[3] - b[1]);
+const inside = (b: number[], x: number, y: number, pad = 0) => x >= b[0] - pad && x <= b[2] + pad && y >= b[1] - pad && y <= b[3] + pad;
+const KIND: Record<string, string> = { view: 'View', section: 'Section', detail: 'Detail' };
+const DIM_KIND: Record<string, string> = { linear: 'Length', diameter: 'Diameter', radius: 'Radius', angle: 'Angle' };
+const fmt = (v: number) => (Math.abs(v) < 5e-5 ? 0 : v).toFixed(3).replace(/\.?0+$/, '');
+const where = (file: string | null, line: number | null) => (file ? `${file}${line ? ` line ${line}` : ''}` : '');
+
+export class DrawingsView implements Pane {
+ readonly root: HTMLElement;
+ private pdf: PdfView;
+ private list: DrawingList = { drawings: [], errors: [], building: false };
+ private byKey = new Map<string, DrawingEntry>();
+ private heads = new Map<string, HTMLElement>();
+ private overlays = new Map<string, HTMLElement>();
+ /** Aufgeklappte Warnungen je Blatt. */
+ private openWarn = new Set<string>();
+ private hover: { key: string; hit: Hit } | null = null;
+ private sel: { key: string; hit: Hit; hint: string | null } | null = null;
+ private card: HTMLElement;
+ private status: HTMLElement;
+ private rebuildAll: HTMLButtonElement;
+ private exportBtn: HTMLButtonElement;
+ /** Hinweis, wenn Blätter von einem älteren soma stammen: Ohne Neubau keine Verknüpfung mit 3D. */
+ private note: HTMLElement;
+ private loadSeq = 0;
+ private down: { x: number; y: number } | null = null;
+ private building = new Set<string>();
+
+ constructor(private readonly d: Deps) {
+ this.pdf = new PdfView(DRAWINGS_KEY, d.pdf, {
+ kind: 'drawings', defaultFit: 'page', defaultMode: 'all',
+ decorate: {
+ header: (key, page) => (page === 1 ? this.headOf(key) : null),
+ overlay: (key, page) => (page === 1 ? this.overlayOf(key) : null),
+ thumbLabel: (key) => this.byKey.get(key)?.name ?? null,
+ },
+ });
+ this.card = el('div', { className: 'dw-card', role: 'status' });
+ this.card.hidden = true;
+ this.status = el('span', { className: 'dw-status c3' });
+ this.rebuildAll = el('button', { className: 'btn sm ghost', title: 'Build all drawings again (soma drawing build)' }, icon('refresh', 14, 1.9), 'Rebuild all');
+ this.rebuildAll.addEventListener('click', () => void this.rebuild(null));
+ this.exportBtn = el('button', { className: 'btn sm ghost', title: 'Export the drawings as PDF or DXF' }, icon('export', 14, 1.9), 'Export', icon('down', 12, 2));
+ this.exportBtn.setAttribute('aria-haspopup', 'menu');
+ this.exportBtn.addEventListener('click', () => this.openExport());
+ const bar = el('div', { className: 'dw-bar' }, icon('drawing', 15, 1.8), el('b', { textContent: 'Drawings' }), this.status, el('span', { className: 'grow' }), this.exportBtn, this.rebuildAll);
+ const again = el('button', { className: 'btn sm acc', title: 'Build all drawings again (soma drawing build)' }, icon('refresh', 14, 1.9), 'Rebuild');
+ again.addEventListener('click', () => void this.rebuild(null));
+ this.note = el('div', { className: 'dw-note' }, icon('alert', 14, 2),
+ el('span', { textContent: 'Built with an older soma. Rebuild the drawings to click dimensions and to see views and sections on the model.' }), again);
+ this.note.hidden = true;
+ this.root = el('div', { className: 'dwview' }, bar, this.note, el('div', { className: 'dw-pdf' }, this.pdf.root), this.card);
+ this.pdf.setEmpty(this.emptyNote());
+ // Zeiger über dem Blatt: Treffer über den Index, die Ereignisse kommen von der Textebene der Seite
+ this.root.addEventListener('pointermove', (e) => this.onMove(e));
+ this.root.addEventListener('pointerleave', () => this.setHover(null));
+ this.root.addEventListener('pointerdown', (e) => { this.down = { x: e.clientX, y: e.clientY }; });
+ this.root.addEventListener('click', (e) => this.onClick(e));
+ this.root.addEventListener('keydown', (e) => {
+ if (e.key === 'Escape' && this.sel) { e.preventDefault(); e.stopPropagation(); this.select(null); }
+ });
+ this.refresh();
+ }
+
+ // ---- Pane -----------------------------------------------------------------------------------------------------
+
+ dispose(): void { this.select(null); this.pdf.dispose(); }
+ hidden(): void { this.pdf.hidden(); this.setHover(null); }
+ shown(): void { this.pdf.shown(); for (const e of this.list.drawings) this.d.seen(e); this.renderHeads(); }
+
+ /** Liste neu lesen und die PDFs neu laden (PdfView lädt nur, was sich geändert hat). */
+ refresh(): void { void this.load(); }
+
+ private async load(): Promise<void> {
+ const seq = ++this.loadSeq;
+ let list: DrawingList;
+ try { list = await this.d.list(); } catch { return; }
+ if (seq !== this.loadSeq) return;
+ const sources: { key: string; data: ArrayBuffer; label: string }[] = [];
+ const errors: { key: string; label: string; message: string }[] = [];
+ for (const e of list.drawings) {
+ try { sources.push({ key: e.pdf, data: await this.d.readBinary(e.pdf), label: e.name }); } catch (err) {
+ errors.push({ key: e.pdf, label: e.name, message: `${e.pdf} cannot be read: ${err instanceof Error ? err.message : String(err)}` });
+ }
+ if (seq !== this.loadSeq) return;
+ }
+ for (const x of list.errors) errors.push({ key: `err:${x.file}`, label: x.file, message: `${where(x.file, x.line)}: ${x.message}` });
+ this.list = list;
+ this.byKey = new Map(list.drawings.map((e) => [e.pdf, e]));
+ // Auswahl auf ein Blatt, das es nicht mehr gibt: aufheben. Sonst mit den neuen Angaben weiter
+ if (this.sel && !this.byKey.has(this.sel.key)) this.select(null);
+ this.d.listed(list);
+ if (!this.root.hidden && this.root.isConnected) for (const e of list.drawings) this.d.seen(e);
+ this.renderHeads();
+ this.renderBar();
+ await this.pdf.loadSet(sources, errors);
+ if (seq !== this.loadSeq) return;
+ for (const k of this.overlays.keys()) this.renderOverlay(k);
+ }
+
+ private emptyNote(): HTMLElement {
+ return el('div', { className: 'dw-empty' },
+ el('span', { className: 'ic' }, icon('drawing', 30, 1.4)),
+ el('b', { textContent: 'No drawings yet' }),
+ el('p', { textContent: 'Ask the agent for a technical drawing, for example “Make a drawing of the bracket with all dimensions for manufacturing.” It writes drawings/*.py and builds the sheets with soma drawing build. They appear here.' }));
+ }
+
+ private renderBar(): void {
+ const n = this.list.drawings.length;
+ const busy = this.list.building || this.building.size > 0;
+ const stale = this.list.drawings.filter((e) => e.stale).length;
+ this.status.textContent = busy ? 'Building …' : [n ? plural(n, 'sheet') : '', stale ? `${stale} older than the code` : '', this.list.errors.length ? plural(this.list.errors.length, 'error') : ''].filter(Boolean).join(' · ');
+ this.status.classList.toggle('warn', !busy && (stale > 0 || this.list.errors.length > 0));
+ this.rebuildAll.disabled = busy;
+ this.rebuildAll.hidden = !n && !this.list.errors.length;
+ this.exportBtn.hidden = !n;
+ this.exportBtn.disabled = busy;
+ this.note.hidden = busy || !this.list.drawings.some((e) => !e.linked);
+ }
+
+ private async rebuild(file: string | null): Promise<void> {
+ this.building.add(file ?? '*');
+ this.renderBar();
+ this.renderHeads();
+ let r: { ok: boolean; error?: string };
+ try { r = await this.d.build(file ?? undefined); } catch (e) { r = { ok: false, error: e instanceof Error ? e.message : String(e) }; }
+ this.building.delete(file ?? '*');
+ if (!r.ok && r.error) this.d.toast(`The drawings could not be built: ${r.error}`, 'error');
+ await this.load();
+ }
+
+ // ---- Kopf über jedem Blatt --------------------------------------------------------------------------------------
+
+ private headOf(key: string): HTMLElement {
+ let h = this.heads.get(key);
+ if (!h) {
+ h = el('div', { className: 'dw-head' });
+ h.dataset.key = key;
+ this.heads.set(key, h);
+ }
+ this.renderHead(key);
+ return h;
+ }
+
+ private renderHeads(): void { for (const k of this.heads.keys()) this.renderHead(k); }
+
+ private renderHead(key: string): void {
+ const h = this.heads.get(key);
+ const e = this.byKey.get(key);
+ if (!h) return;
+ if (!e) { h.replaceChildren(); return; }
+ const btn = (ico: string, title: string, on: () => void, disabled = false) => {
+ const b = el('button', { className: 'ibtn s', title, disabled }, icon(ico, 15, 1.9));
+ b.setAttribute('aria-label', title);
+ b.addEventListener('click', (ev) => { ev.stopPropagation(); on(); });
+ return b;
+ };
+ const busy = this.building.has('*') || (!!e.file && this.building.has(e.file)) || this.list.building;
+ const meta = el('span', { className: 'm' }, [e.size, e.scale, plural(e.views.length, 'view'), plural(e.dims.length, 'dimension')].filter(Boolean).join(' · '));
+ const tags: HTMLElement[] = [];
+ if (this.d.isNew(e)) tags.push(el('span', { className: 'tag acc', textContent: 'new' }));
+ if (e.stale) tags.push(el('span', { className: 'tag w', textContent: 'older than the code', title: 'The model or the drawing file changed since this sheet was built. Rebuild it.' }));
+ if (e.warnings.length) {
+ const w = el('button', { className: 'tag w btn-tag', textContent: plural(e.warnings.length, 'warning'), title: 'Show the warnings of the check' });
+ w.setAttribute('aria-expanded', String(this.openWarn.has(key)));
+ w.addEventListener('click', (ev) => { ev.stopPropagation(); if (!this.openWarn.delete(key)) this.openWarn.add(key); this.renderHead(key); });
+ tags.push(w);
+ }
+ const ex: HTMLButtonElement = btn('export', `Export “${e.name}” as PDF or DXF`, () => this.openSheetExport(e, ex), busy);
+ const row = el('div', { className: 'dw-hrow' },
+ el('span', { className: 'dw-name', textContent: e.name, title: where(e.file, e.line) }), meta, ...tags, el('span', { className: 'grow' }),
+ e.file ? btn('code', `Open ${where(e.file, e.line)}`, () => this.d.openCode(e.file!, e.line, e.name)) : null,
+ e.dxf ? btn('f-draw', `Open ${e.dxf}`, () => this.d.openFile(e.dxf!)) : null,
+ ex,
+ e.file ? btn('refresh', busy ? 'Building …' : `Build this sheet again (${e.file})`, () => void this.rebuild(e.file), busy) : null,
+ btn('send', 'Add this sheet and its warnings to the agent\'s input', () => this.d.insert(this.sheetNote(e))));
+ const kids: HTMLElement[] = [row];
+ if (this.openWarn.has(key) && e.warnings.length) {
+ kids.push(el('div', { className: 'dw-warns' }, ...e.warnings.map((w) => this.warnRow(e, w))));
+ }
+ h.replaceChildren(...kids);
+ }
+
+ private warnRow(e: DrawingEntry, w: DrawingWarning): HTMLElement {
+ const r = el('button', { className: 'dw-warn', title: w.file ? `Open ${where(w.file, w.line)}` : '' }, icon('alert', 13, 2), el('span', { textContent: w.message }),
+ w.line ? el('span', { className: 'c3', textContent: `line ${w.line}` }) : null);
+ r.addEventListener('click', (ev) => { ev.stopPropagation(); if (w.file) this.d.openCode(w.file, w.line, `Warning in “${e.name}”`); });
+ r.addEventListener('pointerenter', () => this.flashBox(e.pdf, w.box));
+ r.addEventListener('pointerleave', () => this.flashBox(e.pdf, undefined));
+ return r;
+ }
+
+ // ---- Export ------------------------------------------------------------------------------------------------------
+
+ private openExport(): void {
+ const n = this.list.drawings.length;
+ const go = (what: 'set' | 'pdf' | 'dxf' | 'both') => () => { menus.close(); void this.d.exportFiles(what); };
+ this.d.menu.replaceChildren(
+ el('div', { className: 'mh', textContent: `Export ${plural(n, 'sheet')}` }),
+ menuItem('All sheets as one PDF …', { icon: 'f-pdf', sub: 'one file', onClick: go('set'), disabled: this.list.errors.length > 0 }),
+ menuItem('Each sheet as PDF …', { icon: 'f-pdf', sub: 'into a folder', onClick: go('pdf') }),
+ menuItem('Each sheet as DXF …', { icon: 'f-draw', sub: 'into a folder', onClick: go('dxf') }),
+ menuItem('PDF and DXF of each sheet …', { icon: 'folder', sub: 'into a folder', onClick: go('both') }));
+ menus.toggle(this.d.menu, this.exportBtn, 'right');
+ }
+
+ private openSheetExport(e: DrawingEntry, anchor: HTMLElement): void {
+ const go = (what: 'pdf' | 'dxf') => () => { menus.close(); void this.d.exportFiles(what, e.id); };
+ this.d.menu.replaceChildren(
+ el('div', { className: 'mh', textContent: `Export “${e.name}”` }),
+ menuItem('PDF …', { icon: 'f-pdf', onClick: go('pdf') }),
+ menuItem('DXF …', { icon: 'f-draw', onClick: go('dxf'), disabled: !e.dxf }));
+ menus.toggle(this.d.menu, anchor, 'right');
+ }
+
+ // ---- Ebene über dem Blatt ---------------------------------------------------------------------------------------
+
+ private overlayOf(key: string): HTMLElement {
+ let o = this.overlays.get(key);
+ if (!o) {
+ o = el('div', { className: 'dw-ov' });
+ o.dataset.key = key;
+ this.overlays.set(key, o);
+ }
+ this.renderOverlay(key);
+ return o;
+ }
+
+ /** Rechteck in Blatt-mm als Lage in Prozent der Seite. */
+ private place(node: HTMLElement, e: DrawingEntry, b: number[]): void {
+ const [x0, y0, x1, y1] = e.pageBox;
+ const w = x1 - x0, h = y1 - y0;
+ node.style.left = `${((b[0] - x0) / w) * 100}%`;
+ node.style.top = `${((y1 - b[3]) / h) * 100}%`;
+ node.style.width = `${((b[2] - b[0]) / w) * 100}%`;
+ node.style.height = `${((b[3] - b[1]) / h) * 100}%`;
+ }
+
+ private renderOverlay(key: string): void {
+ const o = this.overlays.get(key);
+ const e = this.byKey.get(key);
+ if (!o) return;
+ if (!e) { o.replaceChildren(); return; }
+ const kids: HTMLElement[] = [];
+ // Warnungen mit Ort: kleine gelbe Marken, der Text steht im Kopf
+ for (const w of e.warnings) {
+ if (!w.box) continue;
+ const m = el('div', { className: 'dw-wmark', title: w.message });
+ this.place(m, e, w.box);
+ kids.push(m);
+ }
+ const mark = (cls: string, hit: Hit, label: string) => {
+ const pad = 1.2; // mm Luft um Maß und Ansicht
+ const b = [hit.box[0] - pad, hit.box[1] - pad, hit.box[2] + pad, hit.box[3] + pad];
+ const m = el('div', { className: `dw-hit ${cls}` }, el('span', { className: 'dw-tag', textContent: label }));
+ if (hit.box[3] > e.pageBox[3] - 12) m.classList.add('below'); // oben am Rand: Schild nach unten
+ this.place(m, e, b);
+ kids.push(m);
+ };
+ if (this.sel?.key === key) mark('sel', this.sel.hit, this.hitLabel(this.sel.hit));
+ if (this.hover?.key === key && !(this.sel?.key === key && this.sameHit(this.sel.hit, this.hover.hit))) mark('hov', this.hover.hit, this.hitLabel(this.hover.hit));
+ if (this.flash?.key === key) { const m = el('div', { className: 'dw-hit flash' }); this.place(m, e, this.flash.box); kids.push(m); }
+ o.replaceChildren(...kids);
+ }
+
+ private flash: { key: string; box: number[] } | null = null;
+ private flashBox(key: string, box: number[] | undefined): void {
+ const prev = this.flash?.key;
+ this.flash = box ? { key, box } : null;
+ if (prev && prev !== key) this.renderOverlay(prev);
+ this.renderOverlay(key);
+ }
+
+ private hitLabel(h: Hit): string {
+ if (h.kind === 'dim') return h.d.label;
+ const v = h.v;
+ return `${v.kind === 'view' ? v.name : `${KIND[v.kind] ?? v.kind} ${v.name}`} · ${v.scale}`;
+ }
+
+ private sameHit(a: Hit, b: Hit): boolean {
+ return a.kind === b.kind && (a.kind === 'dim' ? a.d === (b as typeof a).d : a.v === (b as Extract<Hit, { kind: 'view' }>).v);
+ }
+
+ /** Was liegt an diesem Punkt des Blatts (mm)? Maße vor Ansichten, kleinere vor größeren. */
+ private hitAt(e: DrawingEntry, x: number, y: number): Hit | null {
+ let best: Hit | null = null;
+ for (const d of e.dims) {
+ // Nur die Maßzahl: Maß- und Hilfslinien liegen oft über anderen Maßen und über der Ansicht
+ const b = d.textBox ?? d.box;
+ if (!b || !inside(b, x, y, 0.5)) continue;
+ if (!best || area(b) < area(best.box)) best = { kind: 'dim', d, box: b };
+ }
+ if (best) return best;
+ for (const v of e.views) {
+ if (!inside(v.bbox, x, y, 2)) continue;
+ if (!best || area(v.bbox) < area(best.box)) best = { kind: 'view', v, box: v.bbox };
+ }
+ return best;
+ }
+
+ /** Blatt und Punkt in mm unter dem Zeiger. */
+ private sheetAt(ev: MouseEvent): { key: string; e: DrawingEntry; x: number; y: number } | null {
+ const page = (ev.target as HTMLElement | null)?.closest?.('.pdf-page');
+ const o = page?.querySelector<HTMLElement>('.dw-ov');
+ const key = o?.dataset.key;
+ const e = key ? this.byKey.get(key) : undefined;
+ if (!o || !key || !e) return null;
+ const r = o.getBoundingClientRect();
+ if (r.width < 1 || r.height < 1) return null;
+ const [x0, y0, x1, y1] = e.pageBox;
+ const fx = (ev.clientX - r.left) / r.width, fy = (ev.clientY - r.top) / r.height;
+ if (fx < 0 || fx > 1 || fy < 0 || fy > 1) return null;
+ return { key, e, x: x0 + fx * (x1 - x0), y: y1 - fy * (y1 - y0) };
+ }
+
+ private onMove(ev: PointerEvent): void {
+ if (ev.buttons) return; // beim Markieren von Text nichts hervorheben
+ const s = this.sheetAt(ev);
+ const hit = s ? this.hitAt(s.e, s.x, s.y) : null;
+ this.setHover(s && hit ? { key: s.key, hit } : null);
+ }
+
+ private setHover(h: { key: string; hit: Hit } | null): void {
+ const prev = this.hover;
+ if (prev && h && prev.key === h.key && this.sameHit(prev.hit, h.hit)) return;
+ this.hover = h;
+ if (prev) this.renderOverlay(prev.key);
+ if (h && h.key !== prev?.key) this.renderOverlay(h.key);
+ this.root.classList.toggle('dw-pointer', !!h);
+ }
+
+ private onClick(ev: MouseEvent): void {
+ // Nur echte Klicks: Wer Text markiert oder zieht, will nichts auswählen
+ const moved = this.down ? Math.hypot(ev.clientX - this.down.x, ev.clientY - this.down.y) > 4 : false;
+ if (moved || !document.getSelection()?.isCollapsed) return;
+ const s = this.sheetAt(ev);
+ if (!s) return;
+ const hit = this.hitAt(s.e, s.x, s.y);
+ this.select(hit ? { key: s.key, hit } : null);
+ }
+
+ /** Ansicht oder Maß auswählen: im Blatt orange, in 3D gezeigt, dazu die Karte unten. */
+ select(x: { key: string; hit: Hit } | null): void {
+ const prev = this.sel?.key;
+ if (!x) {
+ if (this.sel) this.d.link.clear();
+ this.sel = null;
+ } else {
+ const e = this.byKey.get(x.key)!;
+ const hint = x.hit.kind === 'view' ? this.d.link.showView(e, x.hit.v) : this.d.link.showDim(e, x.hit.d);
+ this.sel = { ...x, hint };
+ }
+ if (prev) this.renderOverlay(prev);
+ if (this.sel && this.sel.key !== prev) this.renderOverlay(this.sel.key);
+ this.renderCard();
+ }
+
+ // ---- Karte zur Auswahl ------------------------------------------------------------------------------------------
+
+ private renderCard(): void {
+ const s = this.sel;
+ const e = s ? this.byKey.get(s.key) : undefined;
+ this.card.hidden = !s || !e;
+ if (!s || !e) { this.card.replaceChildren(); return; }
+ const h = s.hit;
+ let title: string, meta: string, file: string | null, line: number | null;
+ if (h.kind === 'view') {
+ const v = h.v;
+ title = v.kind === 'view' ? `View ${v.name}` : `${KIND[v.kind] ?? v.kind} ${v.name}`;
+ meta = [v.scale, v.parts?.length ? v.parts.slice(0, 4).join(', ') + (v.parts.length > 4 ? ' …' : '') : ''].filter(Boolean).join(' · ');
+ file = v.file ?? e.file; line = v.line;
+ } else {
+ const d = h.d;
+ title = d.label;
+ meta = `${DIM_KIND[d.kind] ?? d.kind} in ${d.view} · measured ${fmt(d.value)}${d.kind === 'angle' ? '°' : ' mm'}`;
+ file = d.file ?? e.file; line = d.line;
+ }
+ const lines: HTMLElement[] = [];
+ if (!e.linked) lines.push(el('div', { className: 'dw-cline warn' }, icon('alert', 13, 2), el('span', { textContent: 'Built with an older soma: only the direction is known. Rebuild the drawing to zoom to its parts, cut sections and click dimensions.' })));
+ if (e.stale) lines.push(el('div', { className: 'dw-cline warn' }, icon('alert', 13, 2), el('span', { textContent: 'The sheet is older than the code: in 3D it may not match the model.' })));
+ if (s.hint) lines.push(el('div', { className: 'dw-cline' }, icon('info', 13, 2), el('span', { textContent: s.hint })));
+ const code = el('button', { className: 'btn sm', title: file ? `Open ${where(file, line)}` : '', disabled: !file }, icon('code', 14, 1.9), 'Code');
+ code.addEventListener('click', () => { if (file) this.d.openCode(file, line, title); });
+ const agent = el('button', { className: 'btn sm acc', title: 'Add this to the agent\'s input' }, icon('send', 14, 1.9), 'Send to agent');
+ agent.addEventListener('click', () => this.d.insert(this.hitNote(e, h)));
+ const close = el('button', { className: 'ibtn s', title: 'Clear the selection (Escape)' }, icon('x', 14, 2));
+ close.setAttribute('aria-label', 'Clear the selection');
+ close.addEventListener('click', () => this.select(null));
+ this.card.replaceChildren(
+ el('div', { className: 'dw-chead' }, el('div', {}, el('div', { className: 't', textContent: title }), el('div', { className: 'm', textContent: `${e.name} · ${meta}` })), close),
+ ...lines,
+ el('div', { className: 'dw-cacts' }, code, el('span', { className: 'grow' }), agent));
+ }
+
+ // ---- Text für den Agenten ---------------------------------------------------------------------------------------
+
+ private sheetNote(e: DrawingEntry): string {
+ const warn = e.warnings.length ? `, ${plural(e.warnings.length, 'warning')}: ${e.warnings.map((w) => `${w.message}${w.line ? ` (line ${w.line})` : ''}`).join('; ')}` : '';
+ return `[Drawing: "${e.name}" (${where(e.file, e.line) || e.pdf}), ${e.pdf}${e.stale ? ', older than the code' : ''}${warn}] `;
+ }
+
+ private hitNote(e: DrawingEntry, h: Hit): string {
+ if (h.kind === 'view') {
+ const v = h.v;
+ return `[Drawing "${e.name}", ${v.kind === 'view' ? 'view' : v.kind} "${v.name}" (${where(v.file ?? e.file, v.line)}), scale ${v.scale}] `;
+ }
+ const d = h.d;
+ return `[Drawing "${e.name}", dimension ${d.label} in view "${d.view}" (${where(d.file ?? e.file, d.line)}), measured ${fmt(d.value)}${d.kind === 'angle' ? '°' : ' mm'}] `;
+ }
+
+ // ---- Prüfhilfen -------------------------------------------------------------------------------------------------
+
+ state() {
+ return {
+ sheets: this.list.drawings.map((e) => ({ name: e.name, stale: e.stale, views: e.views.length, dims: e.dims.length, warnings: e.warnings.length })),
+ errors: this.list.errors.length, building: this.list.building,
+ heads: [...this.root.querySelectorAll<HTMLElement>('.dw-head')].map((h) => h.textContent),
+ hover: this.hover ? this.hitLabel(this.hover.hit) : null,
+ selected: this.sel ? { label: this.hitLabel(this.sel.hit), hint: this.sel.hint } : null,
+ card: this.card.hidden ? null : this.card.textContent,
+ pdf: this.pdf.state(),
+ };
+ }
+
+ /** Prüfhilfe: Punkt eines Blatts (mm) auf dem Bildschirm, um dorthin zu zeigen oder zu klicken. */
+ screenOf(name: string, x: number, y: number): { x: number; y: number } | null {
+ const e = this.list.drawings.find((d) => d.name === name);
+ const o = e ? this.overlays.get(e.pdf) : undefined;
+ if (!e || !o?.isConnected) return null;
+ const r = o.getBoundingClientRect();
+ const [x0, y0, x1, y1] = e.pageBox;
+ return { x: r.left + ((x - x0) / (x1 - x0)) * r.width, y: r.top + ((y1 - y) / (y1 - y0)) * r.height };
+ }
+
+ /** Prüfhilfe: zum Blatt springen. */
+ goTo(name: string): void {
+ const e = this.list.drawings.find((d) => d.name === name);
+ if (e) this.pdf.goTo(e.pdf, 1);
+ }
+}
diff --git a/app/src/renderer/drawlink.ts b/app/src/renderer/drawlink.ts
new file mode 100644
index 0000000..b0f424d
--- /dev/null
+++ b/app/src/renderer/drawlink.ts
@@ -0,0 +1,178 @@
+import * as THREE from 'three';
+import type { DrawingDim, DrawingEntry, DrawingView } from '../shared/types';
+import type { SectionTool } from './sectiontool';
+import type { MeasureMarks, Viewer } from './viewer';
+
+// Zeichnung und 3D (E76): Ein Klick auf eine Ansicht des Blatts dreht die Kamera in ihre Blickrichtung, ein Schnitt setzt das
+// Schnittwerkzeug auf seine Ebene, eine Einzelheit rückt heran. Ein Klick auf ein Maß zeigt seine Punkte und die gemessene
+// Strecke im Bild, wie das Messwerkzeug. Alles kommt aus dem Index von `soma drawing build`, der Agent tut dafür nichts.
+
+interface Deps {
+ viewer: Viewer;
+ section: SectionTool;
+ /** Messen, Explosion, Animation und Analyse beenden: Die Punkte gelten für das Modell in seiner Lage. */
+ beforeShow(): void;
+ /** Bauteil-IDs im Viewer zu den Namen aus der Zeichnung (leer: keine passenden). */
+ partIds(names: string[]): string[];
+ /** Alle Bauteil-IDs im Viewer. */
+ allIds(): string[];
+ /** Ist ein Modell geladen? */
+ ready(): boolean;
+}
+
+type V3 = number[];
+const sub = (a: V3, b: V3) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const add = (a: V3, b: V3, k = 1) => [a[0] + b[0] * k, a[1] + b[1] * k, a[2] + b[2] * k];
+const dot = (a: V3, b: V3) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const len = (a: V3) => Math.hypot(a[0], a[1], a[2]);
+const unit = (a: V3) => { const l = len(a); return l > 1e-12 ? a.map((x) => x / l) : null; };
+const cross = (a: V3, b: V3) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+const v3 = (a: V3) => new THREE.Vector3(a[0], a[1], a[2]);
+
+/** Rechts und oben auf dem Blatt; ältere Indizes ohne die Angaben: aus der Blickrichtung mit Z (oder Y) oben. */
+export function axesOf(v: DrawingView): { right: V3; up: V3; n: V3 } {
+ const n = unit(v.direction) ?? [0, -1, 0];
+ if (v.right && v.up) return { right: v.right, up: v.up, n };
+ const up0 = Math.abs(n[2]) > 0.99 ? [0, Math.sign(n[2]) || 1, 0] : [0, 0, 1];
+ const right = unit(cross(up0, n)) ?? [1, 0, 0];
+ return { right, up: cross(n, right), n };
+}
+
+/** Kreis um `c` mit Radius `r` in der Ebene von `a` und `b`, als Strecken. */
+function circle(c: V3, r: number, a: V3, b: V3, segs = 48): { a: V3; b: V3; primary: boolean }[] {
+ const out: { a: V3; b: V3; primary: boolean }[] = [];
+ const at = (i: number) => { const t = (i / segs) * Math.PI * 2; return add(add(c, a, r * Math.cos(t)), b, r * Math.sin(t)); };
+ for (let i = 0; i < segs; i++) out.push({ a: at(i), b: at(i + 1), primary: true });
+ return out;
+}
+
+/** Was ein Maß im Bild zeigt: Punkte, Strecken (die gemessene in Orange) und die Maßzahl. */
+export function dimMarks(d: DrawingDim, v: DrawingView | undefined): MeasureMarks | null {
+ const pts = d.points ?? [];
+ if (!pts.length) return null;
+ const ax = v ? axesOf(v) : { right: [1, 0, 0], up: [0, 0, 1], n: [0, -1, 0] };
+ const lines: MeasureMarks['lines'] = [];
+ let at = pts[0];
+ if ((d.kind === 'diameter' || d.kind === 'radius') && d.radius) {
+ const c = pts[0], r = d.radius;
+ lines.push(...circle(c, r, ax.right, ax.up));
+ // Durchmesser oder Radius schräg wie üblich auf Zeichnungen
+ const diag = unit(add(ax.right, ax.up))!;
+ lines.push({ a: d.kind === 'diameter' ? add(c, diag, -r) : c, b: add(c, diag, r), primary: true });
+ at = add(c, diag, r);
+ } else if (d.kind === 'angle' && pts.length >= 3) {
+ lines.push({ a: pts[0], b: pts[1], primary: true }, { a: pts[0], b: pts[2], primary: true });
+ at = pts[0];
+ } else if (pts.length >= 2) {
+ // Lineares Maß: waagerecht, senkrecht oder schräg auf dem Blatt. Welche Richtung, verrät der gemessene Wert.
+ const [p1, p2] = pts;
+ const delta = sub(p2, p1);
+ const inPlane = sub(delta, ax.n.map((x) => x * dot(delta, ax.n)));
+ const cands: { dir: V3; val: number }[] = [
+ { dir: ax.right, val: Math.abs(dot(delta, ax.right)) }, { dir: ax.up, val: Math.abs(dot(delta, ax.up)) },
+ { dir: unit(inPlane) ?? ax.right, val: len(inPlane) },
+ ];
+ const best = cands.reduce((a, b) => (Math.abs(b.val - d.value) < Math.abs(a.val - d.value) ? b : a));
+ const end = add(p1, best.dir, dot(delta, best.dir));
+ lines.push({ a: p1, b: end, primary: true });
+ if (len(sub(end, p2)) > 1e-6) lines.push({ a: end, b: p2 });
+ at = add(p1, sub(end, p1), 0.5);
+ }
+ return { entities: [], points: pts.slice(0, d.kind === 'angle' ? 3 : 2), lines, label: { at, text: d.label } };
+}
+
+export class DrawingLink {
+ /** Den Schnitt hat die Zeichnung gesetzt: Beim Verlassen nimmt sie ihn wieder weg. */
+ private ownSection = false;
+ private ownMarks = false;
+ /** Die übrigen Teile sind durchsichtig (Zustand der Animation im Viewer, die Animation ist dabei aus). */
+ private ownGhost = false;
+
+ constructor(private readonly d: Deps) {}
+
+ /** Ansicht im Bild zeigen. Liefert einen Hinweis für die Karte oder null. */
+ showView(e: DrawingEntry, v: DrawingView): string | null {
+ if (!this.d.ready()) return 'The model is not loaded, so there is nothing to show in 3D.';
+ this.d.beforeShow();
+ this.clearMarks();
+ const ids = this.d.partIds(v.parts ?? []);
+ this.focus(ids);
+ const { n, right, up } = axesOf(v);
+ let hint: string | null = null;
+ if (v.section?.kind === 'plane' && v.section.point && v.section.normal) {
+ this.d.section.showPlane(v.section.point, v.section.normal, `section ${v.name} of “${e.name}”`);
+ this.ownSection = true;
+ hint = 'The section tool shows the same cut. Its slider moves the plane.';
+ } else {
+ this.dropSection();
+ if (v.kind === 'section') hint = 'A stepped section or break-out cannot be shown as one plane in 3D.';
+ }
+ if (v.detail) {
+ // Kreis der Einzelheit im Bild, die Kamera rückt auf ihn
+ const c = v.detail.center, r = v.detail.radius;
+ this.d.viewer.setMeasureMarks({ entities: [], points: [], lines: circle(c, r, right, up).map((l) => ({ ...l, primary: false })),
+ label: { at: add(c, unit(add(right, up))!, r), text: v.name } });
+ this.ownMarks = true;
+ this.d.viewer.frame(v3(n), v3(c), r * 1.5);
+ } else this.d.viewer.viewFrom(v3(n), ids.length ? ids : undefined);
+ if (v.parts?.length && !ids.length && !hint) hint = 'The parts of this view are not in the model any more.';
+ return hint;
+ }
+
+ /** Maß im Bild zeigen: Kamera wie in seiner Ansicht, dazu Punkte und Strecke. */
+ showDim(e: DrawingEntry, d: DrawingDim): string | null {
+ if (!this.d.ready()) return 'The model is not loaded, so there is nothing to show in 3D.';
+ const v = e.views.find((x) => x.name === d.view);
+ const marks = dimMarks(d, v);
+ if (!marks) return 'This sheet was built by an older soma without the points of its dimensions. Rebuild it.';
+ this.d.beforeShow();
+ this.dropSection();
+ this.d.viewer.setMeasureMarks(marks);
+ this.ownMarks = true;
+ if (v) {
+ const ids = this.d.partIds(v.parts ?? []);
+ this.focus(ids);
+ if (v.detail) this.d.viewer.frame(v3(axesOf(v).n), v3(v.detail.center), v.detail.radius * 1.5);
+ else this.d.viewer.viewFrom(v3(axesOf(v).n), ids.length ? ids : undefined);
+ }
+ return null;
+ }
+
+ /** Auswahl in der Zeichnung aufgehoben: Marken und den eigenen Schnitt wegnehmen, die Kamera bleibt. */
+ clear(): void {
+ this.clearMarks();
+ this.dropSection();
+ this.focus([]);
+ }
+
+ /**
+ * Ein anderes Werkzeug übernimmt das Bild (Messen, Animation, Analyse, Explosion): Marken und Zustände gehören jetzt ihm,
+ * ein späteres clear() darf sie nicht wegnehmen.
+ */
+ release(): void { this.ownMarks = false; this.ownGhost = false; }
+
+ /** Zeigt die Ansicht nur einen Teil des Modells, werden die übrigen Teile durchsichtig. Leer: alle wieder normal. */
+ private focus(ids: string[]): void {
+ const all = this.d.allIds();
+ const keep = new Set(ids);
+ const others = all.filter((id) => !keep.has(id));
+ if (ids.length && others.length) {
+ this.d.viewer.setAnimState({ hidden: new Set(), ghost: new Set(others), highlight: new Set() });
+ this.ownGhost = true;
+ } else if (this.ownGhost) {
+ this.d.viewer.setAnimState(null);
+ this.ownGhost = false;
+ }
+ }
+
+ private clearMarks(): void {
+ if (this.ownMarks) this.d.viewer.setMeasureMarks(null);
+ this.ownMarks = false;
+ }
+
+ private dropSection(): void {
+ // Nur wenn der Schnitt noch der aus der Zeichnung ist: Hat der Nutzer ihn inzwischen umgestellt, gehört er ihm
+ if (this.ownSection && this.d.section.fromDrawing) this.d.section.setActive(false);
+ this.ownSection = false;
+ }
+}
diff --git a/app/src/renderer/icons.ts b/app/src/renderer/icons.ts
index fd07002..227b9b3 100644
--- a/app/src/renderer/icons.ts
+++ b/app/src/renderer/icons.ts
@@ -76,6 +76,8 @@ const PATHS: Record<string, string> = {
// Animation, Analyse und Video (E58)
pause: '<path d="M8 5v14M16 5v14"/>',
anim: '<rect x="3" y="5" width="18" height="14" rx="2"/><path d="m10 9 5 3-5 3z"/>',
+ // Zeichnungen (E76): Blatt quer mit Schriftfeld unten rechts und einer Ansicht
+ drawing: '<rect x="2.5" y="4.5" width="19" height="15" rx="1"/><path d="M13 19.5v-4.5h8.5"/><rect x="5.5" y="8" width="5" height="4.5"/><path d="M13.5 10.2h4.5"/>',
gauge: '<path d="M4.2 17a8.5 8.5 0 1 1 15.6 0"/><path d="m12 14 4.5-5"/><circle cx="12" cy="14" r="1.2"/>',
stepback: '<path d="M18 6v12l-8-6zM6 6v12"/>', stepfwd: '<path d="M6 6v12l8-6zM18 6v12"/>',
loop: '<path d="M17 3l3 3-3 3"/><path d="M4 11V9a3 3 0 0 1 3-3h13M7 21l-3-3 3-3"/><path d="M20 13v2a3 3 0 0 1-3 3H4"/>',
@@ -88,6 +90,12 @@ const PATHS: Record<string, string> = {
grid: '<rect x="3.5" y="3.5" width="17" height="17" rx="1.5"/><path d="M3.5 9.2h17M3.5 14.8h17M9.2 3.5v17M14.8 3.5v17"/>',
square: '<rect x="4" y="4" width="16" height="16" rx="1.5"/>', circle: '<circle cx="12" cy="12" r="8"/>',
text: '<path d="M5 6V4h14v2M12 4v16M9 20h6"/>', undo: '<path d="M9 14 4 9l5-5"/><path d="M4 9h11a5 5 0 0 1 0 10h-3"/>',
+ // PDF-Ansicht: alle Seiten untereinander, eine Seite, Vorschauleiste, Seitenbreite und ganze Seite einpassen
+ pages: '<rect x="6" y="2.5" width="12" height="8" rx="1"/><rect x="6" y="13.5" width="12" height="8" rx="1"/>',
+ page1: '<rect x="5.5" y="3" width="13" height="18" rx="1.5"/><path d="M9 8h6M9 12h6M9 16h4"/>',
+ thumbs: '<rect x="3" y="4" width="18" height="16" rx="2"/><path d="M9 4v16M5.3 8h1.4M5.3 12h1.4M5.3 16h1.4"/>',
+ fitw: '<rect x="3" y="5" width="18" height="14" rx="1.5"/><path d="M7 12h10M9.5 9.5 7 12l2.5 2.5M14.5 9.5 17 12l-2.5 2.5"/>',
+ fitp: '<rect x="3" y="3" width="18" height="18" rx="1.5"/><rect x="7.5" y="6" width="9" height="12" rx="1"/>',
};
export function icon(name: string, size = 16, stroke = 1.8): SVGSVGElement {
diff --git a/app/src/renderer/index.html b/app/src/renderer/index.html
index 17f9d10..ce2ed84 100644
--- a/app/src/renderer/index.html
+++ b/app/src/renderer/index.html
@@ -46,6 +46,8 @@
<span class="rail-sep"></span>
<button data-panel="analysis" aria-pressed="false" title="Analyses of the agent: strength (FEM), wall thickness, overhang, clearance. Shows the result in the viewer."><i data-icon="gauge" data-size="20" data-stroke="1.7"></i><span>Analysis</span><i id="nd-analysis" class="nd" hidden></i></button>
<button data-panel="anim" aria-pressed="false" title="Animations and videos of the agent. Plays the animation in the viewer."><i data-icon="anim" data-size="20" data-stroke="1.7"></i><span>Animation</span><i id="nd-anim" class="nd" hidden></i></button>
+ <!-- Zeichnungen (E76): keine Seitenleiste, öffnet das Dokument „Drawings“ in der Code-Spalte (drawings.ts) -->
+ <button id="btn-rail-drawings" aria-pressed="false" title="Technical drawings of the agent: all sheets in one view. Hover a view or a dimension to see it in 3D."><i data-icon="drawing" data-size="20" data-stroke="1.7"></i><span>Drawings</span><i id="nd-drawings" class="nd" hidden></i></button>
<span class="rail-sep"></span>
<button data-panel="skills" aria-pressed="false" title="Skills: rules for the agent, set per model (3D printing, tolerances …)"><i data-icon="book" data-size="20" data-stroke="1.7"></i><span>Skills</span></button>
<span class="grow"></span>
diff --git a/app/src/renderer/main.ts b/app/src/renderer/main.ts
index d0daa98..6a6f8e0 100644
--- a/app/src/renderer/main.ts
+++ b/app/src/renderer/main.ts
@@ -1,10 +1,12 @@
import { affectsBuild } from '../shared/editable';
import { DEFAULT_SETTINGS, type SettingsPatch, type SettingsResult, type SettingsState } from '../shared/settings';
-import type { AgentInfo, AnimEntry, BuildStatus, ExportResult, FileNode, ImportResult, ModelMap, PartMap, PreviewResult, ProjectInfo, ProjectListEntry, ResultEntry, SaveState } from '../shared/types';
+import type { AgentInfo, AnimEntry, BuildStatus, DrawingEntry, DrawingList, ExportResult, FileNode, ImportResult, ModelMap, PartMap, PreviewResult, ProjectInfo, ProjectListEntry, ResultEntry, SaveState } from '../shared/types';
import { AnalysisPanel } from './analysispanel';
import { AnimPanel, animKey, videoKey } from './animpanel';
import { SOMA_VERSION } from '../shared/version';
import { CodePanel, codeRows, isDxf, isPdf, type Mark } from './code';
+import { DRAWINGS_KEY, DrawingsView } from './drawings';
+import { DrawingLink } from './drawlink';
import { AnimTool } from './animtool';
import { Busy } from './busy';
import { DRAG_FILE, FileTree, IMAGE_EXT, TEXT_EXT, VIDEO_EXT } from './filetree';
@@ -145,6 +147,7 @@ function showCode(on: boolean): void {
else if (project) void code.open('model.py');
}
renderLayout();
+ renderDrawingsRail();
}
/** Spalten-Schalter oben rechts: zeigen, welche Spalten offen sind. */
@@ -159,7 +162,8 @@ const code = new CodePanel(
{
read: (rel) => api.fs.readText(rel), readBinary: (rel) => api.fs.readBinary(rel), projectId: () => project?.id ?? null, toast, ask: (o) => api.dialog.choose(o),
changed: () => { if (saveState) renderSaveState(saveState); },
- active: (f) => fileTree?.setActive(f),
+ // Später: Der erste Aufruf kommt schon aus dem Konstruktor, bevor `code` steht
+ active: (f) => { fileTree?.setActive(f); queueMicrotask(renderDrawingsRail); },
saveAndBuild: () => void saveCode(),
build: () => void api.build.run(),
link: (href) => openLink(href),
@@ -586,6 +590,62 @@ const sectionTool = new SectionTool({
hint: $('section-hint'), flip: $<HTMLButtonElement>('btn-section-flip'), look: $<HTMLButtonElement>('btn-section-look'),
}, { viewer });
+// ---- Zeichnungen (E76): Dokument „Drawings“ in der Code-Spalte, Ansichten und Maße in 3D --------------------------
+
+const drawingLink = new DrawingLink({
+ viewer, section: sectionTool,
+ beforeShow: () => endOthers('drawing'),
+ partIds: (names) => {
+ const want = new Set(names);
+ return viewer.partList().filter((p) => want.has(p.name) || want.has(p.id)).map((p) => p.id);
+ },
+ allIds: () => viewer.partList().map((p) => p.id),
+ ready: () => viewer.partList().length > 0,
+});
+const drawingKey = (e: DrawingEntry) => `d:${e.id}:${e.built}`;
+const drawingsView = () => code.pane(DRAWINGS_KEY) as DrawingsView | undefined;
+const drawingsShown = () => codeOpen && code.activeFile === DRAWINGS_KEY;
+
+/** Klick auf „Drawings“ an der Leiste: das Dokument zeigen, ist es schon vorne, die Code-Spalte schließen. */
+function toggleDrawings(): void {
+ if (drawingsShown()) { showCode(false); return; }
+ // Blätter brauchen die Breite: Eine offene Seitenleiste geht zu, wie beim Wechsel zwischen ihren Reitern
+ if (panel) showPanel(null);
+ if (!codeOpen) { codeOpen = true; $('editor').hidden = false; $('split-code').hidden = false; renderLayout(); }
+ code.openPane(DRAWINGS_KEY, 'Drawings', () => new DrawingsView({
+ list: () => api.drawings.list(), build: (f) => api.drawings.build(f), readBinary: (rel) => api.fs.readBinary(rel),
+ pdf: {
+ quote: (file, pages, text) => {
+ const cut = text.length > MAX_QUOTE;
+ insertToAgent(`[Quote: ${file} p. ${pages}: "${cut ? `${text.slice(0, MAX_QUOTE)} …` : text}"] `, cut ? `Quote shortened to ${MAX_QUOTE} characters.` : undefined);
+ },
+ markPage: (file, page, canvas) => void markSource(`${file} p. ${page}`, canvas, canvas.width, canvas.height),
+ },
+ openCode: (file, line, label) => void openCode(file, line ? { from: line, to: line, label } : undefined),
+ openFile: (rel) => void openCode(rel),
+ insert: (t) => insertToAgent(t), toast, link: drawingLink,
+ menu: $('menu-ctx'),
+ exportFiles: async (what, sheet) => {
+ const r = await api.drawings.export(what, sheet);
+ if (r.cancelled) return;
+ const name = (f: string) => f.split(/[\\/]/).pop() ?? f;
+ const warn = r.warnings?.length ? `\n${r.warnings.join('\n')}` : '';
+ if (!r.ok) toast(`Export failed: ${r.error}${warn}`, 'error');
+ else if (r.files.length === 1) toast(`Exported:\n${r.target ?? r.files[0]}${warn}`, warn ? 'info' : 'ok');
+ else toast(`${r.files.length} files exported to ${r.target ?? ''}:\n${r.files.map(name).join(', ')}${warn}`, warn ? 'info' : 'ok');
+ },
+ isNew: (e) => !seen.has(drawingKey(e)), seen: (e) => { seen.add(drawingKey(e)); },
+ listed: (list) => { viewLists.drawings = list.drawings; renderResults(); },
+ }));
+ renderResults();
+}
+
+/** Knopf an der Leiste: gedrückt, solange das Dokument vorne in der offenen Code-Spalte steht. */
+function renderDrawingsRail(): void {
+ $('btn-rail-drawings').setAttribute('aria-pressed', String(drawingsShown()));
+}
+$('btn-rail-drawings').addEventListener('click', () => toggleDrawings());
+
// ---- Explosionsansicht (E56) ----------------------------------------------------------------------------------------
/** Ladeanzeige über dem Viewer, solange die Explosion rechnet. */
@@ -704,7 +764,8 @@ async function sendMarkup(): Promise<void> {
const resultLayer = new ResultLayer(viewer);
/** Zeigt der Viewer gerade eine Analyse oder Animation, sagen es Reiter, Baum und die Leiste unten im Bild (E82). */
/** Messen, Explosion, Animation und Analyse schließen sich aus: Jedes braucht das Modell in seiner eigenen Lage. */
-const endOthers = (keep: 'measure' | 'explode' | 'anim' | 'result') => {
+const endOthers = (keep: 'measure' | 'explode' | 'anim' | 'result' | 'drawing') => {
+ if (keep !== 'drawing') drawingLink.release();
if (keep !== 'measure' && measureTool.isActive) measureTool.setActive(false);
if (keep !== 'explode' && explodeTool.isActive) explodeTool.setActive(false, false);
if (keep !== 'anim') animTool.setActive(false);
@@ -1333,7 +1394,7 @@ async function doExport(fmt: string, label: string): Promise<ExportResult> {
// Analysen, Animationen und Videos sind Ergebnisse des Agenten, keine Werkzeuge. Ein Klick auf den Reiter zeigt die Liste (oder
// den Bericht, wenn schon ein Ergebnis im Bild ist), erst ein Klick in der Liste bringt eins in den Viewer. Das × in der Leiste unten im Bild führt zurück zum Modell.
-let viewLists: { results: ResultEntry[]; anims: AnimEntry[]; videos: string[] } = { results: [], anims: [], videos: [] };
+let viewLists: { results: ResultEntry[]; anims: AnimEntry[]; videos: string[]; drawings: DrawingEntry[] } = { results: [], anims: [], videos: [], drawings: [] };
/** Angesehene Ergebnisse (Schlüssel). Was danach dazukommt, steht in der Liste als „new“, bis man es öffnet. */
const seen = new Set<string>();
/** Ergebnisse, die schon in einem geöffneten Reiter standen. Was nicht darin ist, gibt dem Reiter einen Punkt. */
@@ -1345,6 +1406,7 @@ let viewTimer: ReturnType<typeof setTimeout> | undefined;
const resultKey = (r: ResultEntry) => `r:${r.id}:${String(r.created ?? '')}`;
const analysisKeys = () => viewLists.results.map(resultKey);
const animKeys = () => [...viewLists.anims.map(animKey), ...viewLists.videos.map(videoKey)];
+const drawingKeys = () => viewLists.drawings.map(drawingKey);
function videosIn(nodes: FileNode[], out: string[] = []): string[] {
for (const n of nodes) {
@@ -1356,7 +1418,7 @@ function videosIn(nodes: FileNode[], out: string[] = []): string[] {
function resetViewLists(): void {
viewSeq++;
- viewLists = { results: [], anims: [], videos: [] };
+ viewLists = { results: [], anims: [], videos: [], drawings: [] };
seen.clear();
tabSeen.clear();
seenReady = false;
@@ -1367,15 +1429,16 @@ function resetViewLists(): void {
async function refreshViewLists(): Promise<void> {
if (!project) return;
const seq = ++viewSeq;
- const [results, anims, nodes] = await Promise.all([
+ const [results, anims, nodes, drawings] = await Promise.all([
api.results.list().catch(() => null), api.anim.list().catch(() => null), api.fs.list().catch(() => [] as FileNode[]),
+ api.drawings.list().catch(() => null as DrawingList | null),
]);
if (seq !== viewSeq) return;
- viewLists = { results: results ?? viewLists.results, anims: anims?.animations ?? viewLists.anims, videos: videosIn(nodes) };
+ viewLists = { results: results ?? viewLists.results, anims: anims?.animations ?? viewLists.anims, videos: videosIn(nodes), drawings: drawings?.drawings ?? viewLists.drawings };
if (results) resultTool.setList(results);
if (anims) animTool.setList(anims);
// Was beim Öffnen des Modells schon da ist, gilt als gesehen
- if (!seenReady) { for (const k of [...analysisKeys(), ...animKeys()]) { seen.add(k); tabSeen.add(k); } seenReady = true; }
+ if (!seenReady) { for (const k of [...analysisKeys(), ...animKeys(), ...drawingKeys()]) { seen.add(k); tabSeen.add(k); } seenReady = true; }
renderResults();
}
const scheduleViewLists = () => { clearTimeout(viewTimer); viewTimer = setTimeout(() => void refreshViewLists(), 400); };
@@ -1387,6 +1450,9 @@ function renderResults(): void {
if (panel === 'anim') for (const k of animKeys()) tabSeen.add(k);
$('nd-analysis').hidden = !analysisKeys().some((k) => !tabSeen.has(k));
$('nd-anim').hidden = !animKeys().some((k) => !tabSeen.has(k));
+ if (drawingsShown()) for (const k of drawingKeys()) tabSeen.add(k);
+ $('nd-drawings').hidden = !drawingKeys().some((k) => !tabSeen.has(k));
+ renderDrawingsRail();
if (panel === 'analysis') analysisPanel.render();
if (panel === 'anim') animPanel.render();
// In der Analyse stehen im Baum nur die gerechneten Körper, gegliedert wie im Modell
@@ -1559,6 +1625,7 @@ api.fs.onEditorRequest(async (action) => {
api.dialog.onShow((o) => ask(o));
api.versions.onChanged(() => void versions.refresh());
api.anim.onChanged(() => { void animTool.refresh(); scheduleViewLists(); });
+api.drawings.onChanged(() => { drawingsView()?.refresh(); scheduleViewLists(); });
api.render.onProgress((f) => animTool.progress(f));
// Bilder und Videos, die der Agent erzeugt hat: kurz Bescheid geben, ein Klick im Dateibaum öffnet sie
api.render.onNotice((n) => {
@@ -1702,7 +1769,12 @@ if (api.testMode) {
analysisToggle: (key: string) => analysisPanel.testToggle(key),
animShow: (id: string) => animTool.show(id),
animPanel: () => animPanel.state(),
- rail: () => ({ analysis: !$('nd-analysis').hidden, anim: !$('nd-anim').hidden, pressed: [...document.querySelectorAll<HTMLElement>('#rail [aria-pressed=true]')].map((b) => b.dataset.panel) }),
+ drawings: () => drawingsView()?.state() ?? null,
+ drawingsOpen: () => toggleDrawings(),
+ drawingsScreen: (name: string, x: number, y: number) => drawingsView()?.screenOf(name, x, y) ?? null,
+ drawingsGoTo: (name: string) => drawingsView()?.goTo(name),
+ drawingsSelectNone: () => drawingsView()?.select(null),
+ rail: () => ({ analysis: !$('nd-analysis').hidden, anim: !$('nd-anim').hidden, drawings: !$('nd-drawings').hidden, pressed: [...document.querySelectorAll<HTMLElement>('#rail [aria-pressed=true]')].map((b) => b.dataset.panel) }),
dockCompact: () => $('dock').classList.contains('compact'),
video: () => videoView.state(),
videoOpen: (rel: string) => videoView.open(rel),
diff --git a/app/src/renderer/pdfview.ts b/app/src/renderer/pdfview.ts
index 19e7f5f..e58f2bb 100644
--- a/app/src/renderer/pdfview.ts
+++ b/app/src/renderer/pdfview.ts
@@ -10,11 +10,50 @@ export interface PdfDeps {
markPage(file: string, page: number, canvas: HTMLCanvasElement): void;
}
+/** Eine Datei einer zusammengesetzten Ansicht (loadSet). `key` steht für die Datei in Zitat und Markierung. */
+export interface PdfSource { key: string; data: ArrayBuffer; label?: string }
+
+/** Zusätze je Seite für Ansichten, die auf der PDF-Ansicht aufbauen (etwa die Zeichnungen). */
+export interface PdfDecorator {
+ /** Element shown above the page (inside the scroll area, scrolls with the page, same width as the page). Called when the page box is created. */
+ header?(key: string, pageInSource: number): HTMLElement | null;
+ /** Element laid over the page canvas (absolute, inset 0, above the text layer). Called when the page box is created; sizes in % stay valid on zoom. */
+ overlay?(key: string, pageInSource: number): HTMLElement | null;
+ /** Label under the thumbnail (default: page number). */
+ thumbLabel?(key: string, pageInSource: number): string | null;
+ /** Current page changed (scrolling, single-page navigation). */
+ current?(key: string, pageInSource: number): void;
+}
+
+export interface PdfOptions {
+ /** Art der Ansicht: Ansicht, Einpassen und Vorschauleiste werden je Art gemerkt. */
+ kind?: string;
+ decorate?: PdfDecorator;
+ defaultFit?: Fit;
+ defaultMode?: Mode;
+}
+
+type Mode = 'all' | 'single';
+type Fit = 'width' | 'page';
+
/** Längste Zitate: Mehr passt nicht sinnvoll in eine Eingabezeile des Agenten. Längeres wird gekürzt und gemeldet. */
export const MAX_QUOTE = 2000;
const ZOOMS = [0.5, 0.67, 0.8, 0.9, 1, 1.1, 1.25, 1.5, 1.75, 2, 2.5, 3, 4];
/** Auflösung von „Seite markieren“: so scharf, dass Maßzahlen in Zeichnungen lesbar bleiben. */
const MARK_SCALE = 2.5;
+/** Breite der Vorschaubilder in CSS-Pixeln. Die Leiste selbst ist etwas breiter (style.css, .pdf-thumbs). */
+const THUMB_W = 84;
+/** Schmaler als das ist die Ansicht zu eng für die Vorschauleiste: Sie blendet sich aus, bis wieder Platz ist. */
+const THUMBS_MIN_VIEW = 420;
+/**
+ * Bis zu so vielen Seiten werden alle Seitenformate vorab gelesen (Einpassen je Seite, Platzhalter in richtiger Größe).
+ * Darüber gilt bis zum Zeichnen das Format der ersten Seite der Datei, sonst dauert das Öffnen dicker Datenblätter.
+ */
+const SIZE_ALL_MAX = 300;
+/** Rand um die Seiten (style.css, .pdf-pages padding). */
+const PAD = 16;
+/** Format des Platzhalters für eine Datei, die sich nicht lesen lässt: A4 quer, wie ein Zeichnungsblatt. */
+const ERR_SIZE: [number, number] = [842, 595];
let workerReady = false;
/**
@@ -36,80 +75,185 @@ function ensureWorker(): Promise<void> {
}
}
-interface Page { n: number; box: HTMLElement; canvas: HTMLCanvasElement | null; text: HTMLElement | null; scale: number; task: RenderTask | null; textLayer: TextLayer | null }
+async function parse(data: ArrayBuffer): Promise<PDFDocumentProxy> {
+ await ensureWorker();
+ return getDocument({
+ data: new Uint8Array(data), enableXfa: false, stopAtErrors: false,
+ cMapUrl: 'pdfjs/cmaps/', cMapPacked: true, standardFontDataUrl: 'pdfjs/standard_fonts/', wasmUrl: 'pdfjs/wasm/',
+ }).promise;
+}
+
+function parseError(e: unknown): string {
+ return e instanceof PasswordException ? 'The PDF is password protected. Right-click it in the file tree: “Open with default app”.'
+ : `The PDF cannot be read: ${e instanceof Error ? e.message : String(e)}`;
+}
+
+/** Eine geladene Datei. `doc` fehlt, wenn sie sich nicht lesen ließ: Dann steht sie als eine Platzhalterseite mit `error` da. */
+interface Src { key: string; label: string; sig: string; doc: PDFDocumentProxy | null; error: string | null; count: number }
+
+interface Page {
+ /** Seite in der ganzen Ansicht (1 …), `pin` die Seite in ihrer Datei. */
+ n: number; src: Src; pin: number;
+ /** Format in PDF-Punkten (vorab gelesen oder vom ersten Zeichnen). */
+ size: [number, number];
+ /** Hülle aus Kopf (vom Decorator) und Seite. */
+ wrap: HTMLElement; box: HTMLElement;
+ /** Höhe des Kopfs samt Abstand, zuletzt gemessen: Beim Einpassen der ganzen Seite muss er mit in die Höhe passen. */
+ headH: number;
+ canvas: HTMLCanvasElement | null; text: HTMLElement | null; scale: number; task: RenderTask | null; textLayer: TextLayer | null;
+ thumb: HTMLButtonElement; thumbImg: HTMLElement; thumbDone: boolean;
+ /** Seite gehört nicht mehr zur Ansicht (neu geladen): laufendes Zeichnen verwirft sein Ergebnis. */
+ dead: boolean;
+}
+
+interface Prefs { mode?: Mode; fit?: Fit; thumbs?: boolean }
+
+/** Gemerkte Wahl je Art der Ansicht. localStorage kann fehlen oder werfen, dann gelten die Vorgaben. */
+function loadPrefs(kind: string): Prefs {
+ try {
+ const v: unknown = JSON.parse(localStorage.getItem(`soma.pdf.${kind}`) ?? '{}');
+ if (!v || typeof v !== 'object') return {};
+ const o = v as Record<string, unknown>;
+ return {
+ mode: o.mode === 'all' || o.mode === 'single' ? o.mode : undefined,
+ fit: o.fit === 'width' || o.fit === 'page' ? o.fit : undefined,
+ thumbs: typeof o.thumbs === 'boolean' ? o.thumbs : undefined,
+ };
+ } catch { return {}; }
+}
/**
* PDF-Ansicht im Code-Panel (E54). Seiten werden erst gezeichnet, wenn sie in Sicht kommen, darüber liegt die Textebene
* von pdf.js: Markierter Text geht mit Datei und Seite als Zitat an den Agenten. Gescannte Seiten ohne Text lassen sich
* als Bild markieren. Die Datei kommt aus dem Projekt und ist nicht vertrauenswürdig: kein Skript, kein eval, keine Formulare.
+ *
+ * Alle Seiten untereinander oder eine Seite für sich, links eine Leiste mit Vorschaubildern, Einpassen auf Seitenbreite
+ * oder ganze Seite. Mit loadSet zeigt dieselbe Ansicht mehrere Dateien hintereinander als ein Dokument (Zeichnungen),
+ * ein PdfDecorator legt dann Kopf und Überlagerung je Seite dazu.
*/
export class PdfView {
readonly root: HTMLElement;
private scroller: HTMLElement;
private pagesEl: HTMLElement;
- private bar: { page: HTMLElement; zoom: HTMLElement; quote: HTMLButtonElement; mark: HTMLButtonElement };
- private floatBtn: HTMLButtonElement;
- private doc: PDFDocumentProxy | null = null;
+ private thumbsEl: HTMLElement;
+ private bar: {
+ page: HTMLElement; zoom: HTMLElement; quote: HTMLButtonElement; mark: HTMLButtonElement; thumbs: HTMLButtonElement;
+ prev: HTMLButtonElement; next: HTMLButtonElement; mode: HTMLElement; fit: HTMLElement;
+ };
+ private srcs: Src[] = [];
private pages: Page[] = [];
- /** null = Seitenbreite. */
+ /** null = eingepasst (`fit`). */
private zoom: number | null = null;
- private fitScale = 1;
+ private mode: Mode;
+ private fit: Fit;
+ /** Vorschauleiste gewünscht: null = noch nie umgeschaltet, dann bei mehr als einer Seite. */
+ private thumbsPref: boolean | null;
+ /** Aktuelle Seite in der Einzelansicht. */
+ private cur = 1;
+ /** Nach einem Sprung gilt die angesprungene Seite als aktuell, solange nicht weitergescrollt wird (kurze Seiten am Ende). */
+ private forced: { n: number; top: number } | null = null;
+ /** Sprungziel aus goTo, während noch geladen wird. */
+ private pending: { key: string; pin: number } | null = null;
+ private loading = 0;
+ private lastCur: Page | null = null;
+ private empty: HTMLElement | null = null;
+ private isEmpty = false;
+ private kind: string;
+ private deco: PdfDecorator;
private observer: IntersectionObserver;
+ private thumbObserver: IntersectionObserver;
private resize: ResizeObserver;
- private lastWidth = 0;
+ private viewW = 0;
+ private viewH = 0;
+ /** Breiteste Seite in PDF-Punkten: Beim Einpassen auf Seitenbreite haben alle Seiten denselben Maßstab. */
+ private maxW = 595;
private relayoutTimer: ReturnType<typeof setTimeout> | undefined;
private loadId = 0;
- /** Fingerabdruck der geladenen Datei: Nur wenn er sich ändert, wird neu geladen. */
+ /** Fingerabdruck der geladenen Datei(en): Nur wenn er sich ändert, wird neu geladen. */
private sig = '';
error: string | null = null;
- constructor(readonly file: string, private deps: PdfDeps) {
+ constructor(readonly file: string, private deps: PdfDeps, opts: PdfOptions = {}) {
+ this.kind = opts.kind ?? 'pdf';
+ this.deco = opts.decorate ?? {};
+ const saved = loadPrefs(this.kind);
+ this.mode = saved.mode ?? opts.defaultMode ?? 'all';
+ this.fit = saved.fit ?? opts.defaultFit ?? 'width';
+ this.thumbsPref = saved.thumbs ?? null;
const btn = (ico: string, title: string, onClick: () => void, label = '') => {
- const b = el('button', { className: 'btn sm ghost', title }, icon(ico, 14, 1.9), label);
+ const b = el('button', { className: label ? 'btn sm ghost' : 'btn sm ghost ico', title }, icon(ico, 14, 1.9), label && el('span', { className: 'lbl', textContent: label }));
b.setAttribute('aria-label', title);
b.addEventListener('click', onClick);
return b;
};
+ // Umschalter wie beim Markdown (.cmode): genau einer gewählt, beim Einpassen keiner, sobald von Hand gezoomt ist
+ const seg = (name: string, label: string, items: [string, string, string][], pick: (v: string) => void) => {
+ const g = el('div', { className: 'cmode pdf-seg' });
+ g.dataset.pdf = name;
+ g.setAttribute('role', 'radiogroup');
+ g.setAttribute('aria-label', label);
+ for (const [v, ico, title] of items) {
+ const b = el('button', { title }, icon(ico, 14, 1.9));
+ b.dataset.v = v;
+ b.setAttribute('role', 'radio');
+ b.setAttribute('aria-label', title);
+ b.addEventListener('click', () => pick(v));
+ g.append(b);
+ }
+ return g;
+ };
this.bar = {
page: el('span', { className: 'pdf-page-no c3' }),
zoom: el('span', { className: 'pdf-zoom c3' }),
quote: btn('send', 'Send the selected text to the agent as a quote with its page', () => this.sendQuote(), 'Quote to agent'),
mark: btn('camera', 'Mark up this page as an image (for drawings and scanned pages)', () => void this.markPage(), 'Mark up page'),
+ thumbs: btn('thumbs', 'Page thumbnails', () => this.toggleThumbs()),
+ prev: btn('left', 'Previous page', () => this.go(this.currentPage() - 1)),
+ next: btn('right', 'Next page', () => this.go(this.currentPage() + 1)),
+ mode: seg('mode', 'Page display', [['all', 'pages', 'All pages: scroll through the document'], ['single', 'page1', 'Single page: one page at a time (Page Up/Down, arrow keys)']],
+ (v) => this.setMode(v as Mode)),
+ fit: seg('fit', 'Fit', [['width', 'fitw', 'Fit page width (Ctrl+0)'], ['page', 'fitp', 'Fit whole page']], (v) => this.setFit(v as Fit)),
};
+ this.bar.thumbs.dataset.pdf = 'thumbs';
+ this.bar.prev.dataset.pdf = 'prev';
+ this.bar.next.dataset.pdf = 'next';
const minus = btn('minus', 'Zoom out', () => this.step(-1));
const plus = btn('plus', 'Zoom in', () => this.step(1));
- const fit = btn('fit', 'Fit page width', () => this.setZoom(null));
this.pagesEl = el('div', { className: 'pdf-pages' });
this.scroller = el('div', { className: 'pdf-scroll', tabIndex: -1 }, this.pagesEl);
- this.floatBtn = el('button', { className: 'btn sm acc pdf-float', title: 'Send the selected text to the agent as a quote' }, icon('send', 13, 2), 'Quote to agent');
- this.floatBtn.hidden = true;
- // Mausdruck nicht als Klick ins Dokument werten, sonst ginge die Textauswahl vor dem Klick verloren
- this.floatBtn.addEventListener('mousedown', (e) => e.preventDefault());
- this.floatBtn.addEventListener('click', () => this.sendQuote());
+ this.thumbsEl = el('div', { className: 'pdf-thumbs' });
+ this.thumbsEl.setAttribute('aria-label', 'Page thumbnails');
+ this.thumbsEl.hidden = true;
+ // Mausdruck auf den Knopf nicht als Klick ins Dokument werten, sonst ginge die Textauswahl vor dem Klick verloren
+ this.bar.quote.addEventListener('mousedown', (e) => e.preventDefault());
this.root = el('div', { className: 'pdfview' },
- el('div', { className: 'pdf-bar' }, this.bar.page, el('span', { className: 'grow' }), minus, this.bar.zoom, plus, fit, el('span', { className: 'pdf-sep' }), this.bar.mark, this.bar.quote),
- this.scroller, this.floatBtn);
+ el('div', { className: 'pdf-bar' }, this.bar.thumbs, this.bar.mode, el('span', { className: 'pdf-sep' }), this.bar.prev, this.bar.page, this.bar.next,
+ el('span', { className: 'grow' }), minus, this.bar.zoom, plus, this.bar.fit, el('span', { className: 'pdf-sep' }), this.bar.mark, this.bar.quote),
+ el('div', { className: 'pdf-body' }, this.thumbsEl, this.scroller));
+ this.root.dataset.kind = this.kind;
this.observer = new IntersectionObserver((list) => {
for (const e of list) if (e.isIntersecting) void this.renderPage(this.pages[Number((e.target as HTMLElement).dataset.page) - 1]);
}, { root: this.scroller, rootMargin: '600px 0px' });
+ this.thumbObserver = new IntersectionObserver((list) => {
+ for (const e of list) if (e.isIntersecting) void this.renderThumb(this.pages[Number((e.target as HTMLElement).dataset.page) - 1]);
+ }, { root: this.thumbsEl, rootMargin: '300px 0px' });
this.resize = new ResizeObserver(() => {
- const w = this.scroller.clientWidth;
- if (w && Math.abs(w - this.lastWidth) > 2 && this.zoom == null) this.relayoutSoon();
+ if (!this.root.clientWidth) return; // versteckter Reiter: erst beim Zeigen neu einpassen
+ this.updateThumbs();
+ const w = this.scroller.clientWidth, h = this.scroller.clientHeight;
+ if (w && this.zoom == null && (Math.abs(w - this.viewW) > 2 || (this.fit === 'page' && Math.abs(h - this.viewH) > 2))) this.relayoutSoon();
});
+ this.resize.observe(this.root);
this.resize.observe(this.scroller);
this.scroller.addEventListener('scroll', () => { this.updatePageNo(); this.updateSelection(); });
document.addEventListener('selectionchange', this.onSelection);
- this.scroller.addEventListener('keydown', (e) => {
- if (!e.ctrlKey || e.altKey) return;
- if (e.key === '+' || e.key === '=') { e.preventDefault(); this.step(1); }
- else if (e.key === '-') { e.preventDefault(); this.step(-1); }
- else if (e.key === '0') { e.preventDefault(); this.setZoom(null); }
- });
+ this.root.addEventListener('keydown', (e) => this.onKey(e));
this.scroller.addEventListener('wheel', (e) => {
if (!e.ctrlKey) return;
e.preventDefault();
this.step(e.deltaY < 0 ? 1 : -1);
}, { passive: false });
+ this.root.classList.toggle('single', this.mode === 'single');
this.updateBar();
}
@@ -119,71 +263,207 @@ export class PdfView {
if (sig === this.sig) return;
this.sig = sig;
const id = ++this.loadId;
- const keepTop = this.scroller.scrollTop;
- await ensureWorker();
- let doc: PDFDocumentProxy;
+ this.loading++;
try {
- doc = await getDocument({
- data: new Uint8Array(data), enableXfa: false, stopAtErrors: false,
- cMapUrl: 'pdfjs/cmaps/', cMapPacked: true, standardFontDataUrl: 'pdfjs/standard_fonts/', wasmUrl: 'pdfjs/wasm/',
- }).promise;
- } catch (e) {
- if (id !== this.loadId) return;
- this.error = e instanceof PasswordException ? 'The PDF is password protected. Right-click it in the file tree: “Open with default app”.'
- : `The PDF cannot be read: ${e instanceof Error ? e.message : String(e)}`;
- this.showMessage(this.error);
- return;
- }
- if (id !== this.loadId) { void doc.loadingTask.destroy(); return; }
- this.error = null;
- this.clearPages();
- void this.doc?.loadingTask.destroy();
- this.doc = doc;
- const first = await doc.getPage(1);
- const vp = first.getViewport({ scale: 1 });
- this.pageSize = [vp.width, vp.height];
- for (let n = 1; n <= doc.numPages; n++) {
- const box = el('div', { className: 'pdf-page' });
- box.dataset.page = String(n);
- box.append(el('span', { className: 'pdf-pnum', textContent: String(n) }));
- this.pagesEl.append(box);
- this.pages.push({ n, box, canvas: null, text: null, scale: 0, task: null, textLayer: null });
- }
- this.layout();
- this.scroller.scrollTop = keepTop;
- for (const p of this.pages) this.observer.observe(p.box);
- this.updateBar();
+ let doc: PDFDocumentProxy;
+ try { doc = await parse(data); } catch (e) {
+ if (id !== this.loadId) return;
+ this.error = parseError(e);
+ this.showMessage(this.error);
+ return;
+ }
+ if (id !== this.loadId) { void doc.loadingTask.destroy(); return; }
+ const src: Src = { key: this.file, label: '', sig, doc, error: null, count: doc.numPages };
+ const sizes = await readSizes([src]);
+ if (id !== this.loadId) { void doc.loadingTask.destroy(); return; }
+ this.error = null;
+ this.install([src], sizes, []);
+ } finally { this.loading--; }
+ }
+
+ /**
+ * Mehrere Dateien hintereinander als ein Dokument (Zeichnungen). Unveränderte Dateien werden nicht neu gelesen, gleicher
+ * Inhalt insgesamt: nichts zu tun. Eine Datei, die sich nicht lesen lässt, steht als Platzhalterseite mit der Meldung da,
+ * `errors` (etwa Blätter, die gar nicht gebaut wurden) als Meldungen nach den Seiten.
+ */
+ async loadSet(sources: PdfSource[], errors: { key: string; label: string; message: string }[] = []): Promise<void> {
+ const sigs = sources.map((s) => `${s.key}\u0000${s.label ?? ''}\u0000${signature(s.data)}`);
+ const sig = `set\u0001${sigs.join('\u0001')}\u0002${JSON.stringify(errors.map((e) => [e.key, e.label, e.message]))}`;
+ if (sig === this.sig) return;
+ this.sig = sig;
+ const id = ++this.loadId;
+ this.loading++;
+ try {
+ const old = new Map(this.srcs.filter((s) => s.doc).map((s) => [s.sig, s]));
+ const srcs = await Promise.all(sources.map(async (s, i): Promise<Src> => {
+ const prev = old.get(sigs[i]);
+ if (prev) { old.delete(sigs[i]); return { ...prev }; }
+ try {
+ const doc = await parse(s.data);
+ return { key: s.key, label: s.label ?? '', sig: sigs[i], doc, error: null, count: doc.numPages };
+ } catch (e) {
+ return { key: s.key, label: s.label ?? '', sig: sigs[i], doc: null, error: parseError(e), count: 1 };
+ }
+ }));
+ const discard = () => {
+ const keep = new Set(this.srcs.map((s) => s.doc));
+ for (const s of srcs) if (s.doc && !keep.has(s.doc)) void s.doc.loadingTask.destroy();
+ };
+ if (id !== this.loadId) { discard(); return; }
+ const sizes = await readSizes(srcs);
+ if (id !== this.loadId) { discard(); return; }
+ this.error = null;
+ this.install(srcs, sizes, errors);
+ } finally { this.loading--; }
}
- /** Größe der ersten Seite in PDF-Punkten. Alle Seiten bekommen zunächst ihr Format, bis sie gezeichnet sind. */
- private pageSize: [number, number] = [595, 842];
+ /** Was die Ansicht zeigt, wenn loadSet nichts bekommt (weder Dateien noch Meldungen). */
+ setEmpty(content: HTMLElement): void {
+ this.empty = content;
+ if (this.isEmpty) this.pagesEl.replaceChildren(content);
+ }
+
+ /** Zur Seite einer Datei springen (Einzelansicht: umschalten). Läuft noch ein Laden, gilt der Sprung danach. */
+ goTo(key: string, pageInSource = 1): void {
+ const p = this.findPage(key, pageInSource);
+ if (!p || this.loading) this.pending = { key, pin: pageInSource };
+ if (p) this.go(p.n);
+ }
+
+ currentSource(): { key: string; page: number } | null {
+ const p = this.pages[this.currentPage() - 1];
+ return p ? { key: p.src.key, page: p.pin } : null;
+ }
+
+ /** Das .pdf-page-Element einer Seite (für Überlagerungen und Tests). */
+ pageBox(key: string, pageInSource: number): HTMLElement | null {
+ return this.pages.find((p) => p.src.key === key && p.pin === pageInSource)?.box ?? null;
+ }
dispose(): void {
this.loadId++;
this.observer.disconnect();
+ this.thumbObserver.disconnect();
this.resize.disconnect();
document.removeEventListener('selectionchange', this.onSelection);
clearTimeout(this.relayoutTimer);
this.clearPages();
- void this.doc?.loadingTask.destroy();
- this.doc = null;
+ this.destroyDocs(new Set());
+ this.srcs = [];
}
- /** Beim Wechsel des Reiters: Die Auswahl und der schwebende Knopf gehören nur zur sichtbaren Ansicht. */
- hidden(): void { this.floatBtn.hidden = true; }
+ /** Beim Wechsel des Reiters: Die Auswahl gehört nur zur sichtbaren Ansicht. */
+ hidden(): void { this.updateSelection(); }
/**
* Reiter wieder sichtbar: War die Ansicht beim Laden versteckt (Breite 0) oder hat sich das Panel inzwischen verändert,
* gleich neu einpassen. Der ResizeObserver allein reicht nicht, er meldet sich erst beim nächsten Zeichnen des Fensters.
*/
shown(): void {
- if (this.pages.length && Math.abs(this.scroller.clientWidth - this.lastWidth) > 2) { this.layout(); this.updateBar(); }
+ this.updateThumbs();
+ if (this.pages.length && (Math.abs(this.scroller.clientWidth - this.viewW) > 2 || Math.abs(this.scroller.clientHeight - this.viewH) > 2)) {
+ // Die zuletzt gemeldete Seite, nicht neu ausgerechnet: Die Lage der Seiten stammt noch aus der alten Breite
+ const n = this.lastCur && !this.lastCur.dead ? this.lastCur.n : 1;
+ this.layout();
+ if (this.mode === 'all' && n > 1) this.scrollToPage(n);
+ }
+ this.updateBar();
+ }
+
+ // ---- Laden ------------------------------------------------------------------------------------------------------
+
+ /** Baut die Seiten neu auf und hält dabei die Stelle, an der man war (gleiche Datei und Seite, sonst gleiche Nummer). */
+ private install(srcs: Src[], sizes: [number, number][][], errors: { key: string; label: string; message: string }[]): void {
+ const anchor = this.anchor();
+ this.destroyDocs(new Set(srcs.map((s) => s.doc)));
+ this.clearPages();
+ this.srcs = srcs;
+ let n = 0;
+ srcs.forEach((s, i) => { for (let pin = 1; pin <= s.count; pin++) this.addPage(++n, s, pin, sizes[i][pin - 1] ?? sizes[i][0] ?? ERR_SIZE); });
+ for (const e of errors) {
+ this.pagesEl.append(el('div', { className: 'pdf-err' }, icon('alert', 15, 2),
+ el('div', {}, e.label && el('b', { textContent: e.label }), e.label && ' ', el('span', { textContent: e.message }))));
+ }
+ this.isEmpty = !this.pages.length && !errors.length;
+ if (this.isEmpty && this.empty) this.pagesEl.append(this.empty);
+ this.maxW = Math.max(1, ...this.pages.map((p) => p.size[0]));
+ this.updateThumbs();
+
+ // Wohin: offener Sprung, sonst dieselbe Seite derselben Datei, sonst dieselbe Datei, sonst dieselbe Nummer
+ let target: Page | undefined, off = 0, jump = false;
+ if (this.pending) { target = this.findPage(this.pending.key, this.pending.pin); this.pending = null; jump = true; }
+ else if (anchor) {
+ target = this.findPage(anchor.key, anchor.pin) ?? this.pages[Math.min(anchor.n, this.pages.length) - 1];
+ off = anchor.off;
+ }
+ if (this.mode === 'single') {
+ this.showPage(target?.n ?? 1);
+ this.scroller.scrollTop = jump ? 0 : off;
+ } else {
+ this.layout();
+ if (target && jump) this.scrollToPage(target.n);
+ else this.scroller.scrollTop = target ? Math.max(0, target.wrap.offsetTop + off) : 0;
+ }
+ for (const p of this.pages) { this.observer.observe(p.box); this.thumbObserver.observe(p.thumb); }
+ this.updateBar();
+ }
+
+ private addPage(n: number, src: Src, pin: number, size: [number, number]): void {
+ const box = el('div', { className: src.doc ? 'pdf-page' : 'pdf-page pdf-errpage' });
+ box.dataset.page = String(n);
+ box.append(el('span', { className: 'pdf-pnum', textContent: String(n) }));
+ const wrap = el('div', { className: 'pdf-sheet' });
+ wrap.dataset.page = String(n);
+ const head = this.decorate(() => this.deco.header?.(src.key, pin));
+ if (head) wrap.append(head);
+ wrap.append(box);
+ if (!src.doc) {
+ const text = head || !src.label ? src.error ?? '' : `${src.label}: ${src.error ?? ''}`;
+ box.append(el('div', { className: 'pdf-errpage-msg' }, icon('alert', 18, 2), el('span', { textContent: text })));
+ } else {
+ // Über Leinwand und Textebene, selbst ohne Mauswirkung: Die Kinder des Decorators entscheiden, wo sie Klicks wollen
+ const over = this.decorate(() => this.deco.overlay?.(src.key, pin));
+ if (over) box.append(el('div', { className: 'pdf-overlay' }, over));
+ }
+ this.pagesEl.append(wrap);
+ const label = this.decorate(() => this.deco.thumbLabel?.(src.key, pin)) ?? String(n);
+ const thumbImg = el('div', { className: src.doc ? 'pdf-thumb-img' : 'pdf-thumb-img err' }, !src.doc && icon('alert', 18, 2));
+ thumbImg.style.height = `${Math.round(THUMB_W * size[1] / size[0])}px`;
+ const thumb = el('button', { className: 'pdf-thumb', title: label }, thumbImg, el('span', { className: 'pdf-thumb-label', textContent: label }));
+ thumb.dataset.page = String(n);
+ thumb.setAttribute('aria-label', `Page ${n}: ${label}`);
+ thumb.addEventListener('click', () => { this.go(n); this.scroller.focus({ preventScroll: true }); });
+ this.thumbsEl.append(thumb);
+ this.pages.push({ n, src, pin, size, wrap, box, headH: 0, canvas: null, text: null, scale: 0, task: null, textLayer: null, thumb, thumbImg, thumbDone: false, dead: false });
+ }
+
+ /** Aufruf in den Decorator: Ein Fehler dort soll nicht die ganze Ansicht mitnehmen. */
+ private decorate<T>(f: () => T | null | undefined): T | null {
+ try { return f() ?? null; } catch (e) { console.error('PDF decorator', e); return null; }
+ }
+
+ private anchor(): { key: string; pin: number; n: number; off: number } | null {
+ if (!this.pages.length) return null;
+ const p = this.pages[this.currentPage() - 1];
+ return { key: p.src.key, pin: p.pin, n: p.n, off: this.mode === 'single' ? this.scroller.scrollTop : this.scroller.scrollTop - p.wrap.offsetTop };
+ }
+
+ private findPage(key: string, pin: number): Page | undefined {
+ return this.pages.find((p) => p.src.key === key && p.pin === pin) ?? this.pages.find((p) => p.src.key === key);
+ }
+
+ /** Gibt die Dokumente frei, die nicht weiter gebraucht werden. */
+ private destroyDocs(keep: Set<PDFDocumentProxy | null>): void {
+ for (const s of this.srcs) if (s.doc && !keep.has(s.doc)) void s.doc.loadingTask.destroy();
}
// ---- Zitat und Seite --------------------------------------------------------------------------------------------
- /** Markierter Text in dieser Ansicht mit den Seiten, auf denen er steht. */
- selection(): { text: string; pages: string; rect: DOMRect | null } | null {
+ /**
+ * Markierter Text in dieser Ansicht mit der Datei und den Seiten, auf denen er steht. Reicht die Auswahl über zwei
+ * Dateien, zählt die erste.
+ */
+ selection(): { key: string; text: string; pages: string; rect: DOMRect | null } | null {
const sel = document.getSelection();
if (!sel || sel.isCollapsed || !sel.rangeCount) return null;
const range = sel.getRangeAt(0);
@@ -194,31 +474,46 @@ export class PdfView {
const a = pageOf(range.startContainer), b = pageOf(range.endContainer);
const lo = Math.min(a || b, b || a), hi = Math.max(a, b);
const rects = [...range.getClientRects()].filter((r) => r.width > 0);
- return { text, pages: !lo ? '?' : lo === hi ? String(lo) : `${lo}–${hi}`, rect: rects.length ? rects[rects.length - 1] : null };
+ const pa = this.pages[lo - 1], pb = this.pages[hi - 1];
+ let key = this.file, pages = '?';
+ if (pa) {
+ key = pa.src.key;
+ const end = pb && pb.src === pa.src ? pb.pin : pa.src.count;
+ pages = end === pa.pin ? String(pa.pin) : `${pa.pin}–${end}`;
+ }
+ return { key, text, pages, rect: rects.length ? rects[rects.length - 1] : null };
}
sendQuote(): void {
const s = this.selection();
if (!s) return;
- this.deps.quote(this.file, s.pages, s.text);
+ this.deps.quote(s.key, s.pages, s.text);
}
+ /** Seite `n` der ganzen Ansicht als Bild auf die Zeichenfläche, unter ihrer Datei und Seite darin. */
async markPage(n = this.currentPage()): Promise<void> {
- if (!this.doc) return;
- const page = await this.doc.getPage(n);
+ const p = this.pages[n - 1];
+ if (!p?.src.doc) return;
+ const page = await p.src.doc.getPage(p.pin);
const vp = page.getViewport({ scale: MARK_SCALE });
const c = el('canvas', { width: Math.round(vp.width), height: Math.round(vp.height) });
const g = c.getContext('2d')!;
g.fillStyle = '#fff'; // PDF-Seiten sind weiß, auch wenn die Datei keinen Hintergrund malt
g.fillRect(0, 0, c.width, c.height);
await page.render({ canvas: c, canvasContext: g, viewport: vp }).promise;
- this.deps.markPage(this.file, n, c);
+ this.deps.markPage(p.src.key, p.pin, c);
}
currentPage(): number {
- const top = this.scroller.scrollTop + this.scroller.clientHeight / 3;
+ if (!this.pages.length) return 1;
+ if (this.mode === 'single') return Math.min(Math.max(1, this.cur), this.pages.length);
+ if (this.forced && Math.abs(this.forced.top - this.scroller.scrollTop) < 2) return this.forced.n;
+ // Versteckt (Reiter im Hintergrund) liegen alle Seiten bei 0: dann gilt die zuletzt aktuelle Seite
+ if (!this.scroller.clientHeight) return this.lastCur && !this.lastCur.dead ? this.lastCur.n : 1;
+ this.forced = null;
+ const top =this.scroller.scrollTop + this.scroller.clientHeight / 3;
let cur = 1;
- for (const p of this.pages) { if (p.box.offsetTop <= top) cur = p.n; else break; }
+ for (const p of this.pages) { if (p.wrap.offsetTop <= top) cur = p.n; else break; }
return cur;
}
@@ -226,15 +521,148 @@ export class PdfView {
private updateSelection(): void {
const s = this.root.isConnected && !this.root.hidden ? this.selection() : null;
+ // Kein schwebender Knopf am Text (störte beim Lesen): Der Knopf oben wird orange, sobald etwas markiert ist
this.bar.quote.disabled = !s;
- if (!s?.rect) { this.floatBtn.hidden = true; return; }
- const host = this.root.getBoundingClientRect();
- this.floatBtn.hidden = false;
- const w = this.floatBtn.offsetWidth || 120;
- const x = Math.min(Math.max(8, s.rect.right - host.left - w / 2), host.width - w - 8);
- const y = Math.min(s.rect.bottom - host.top + 8, host.height - 36);
- this.floatBtn.style.left = `${x}px`;
- this.floatBtn.style.top = `${Math.max(44, y)}px`;
+ this.bar.quote.classList.toggle('acc', !!s);
+ this.bar.quote.classList.toggle('ghost', !s);
+ }
+
+ // ---- Ansicht, Blättern, Vorschauleiste --------------------------------------------------------------------------
+
+ private setMode(m: Mode): void {
+ if (m === this.mode) return;
+ const n = this.currentPage();
+ this.mode = m;
+ this.savePrefs();
+ this.root.classList.toggle('single', m === 'single');
+ if (m === 'single') this.showPage(n);
+ else {
+ for (const p of this.pages) p.wrap.hidden = false;
+ this.layout();
+ this.scrollToPage(n);
+ }
+ this.updateBar();
+ }
+
+ /** Zu Seite `n` der ganzen Ansicht: in der Einzelansicht umschalten, sonst hinscrollen. */
+ private go(n: number, atEnd = false): void {
+ if (!this.pages.length) return;
+ n = Math.min(Math.max(1, n), this.pages.length);
+ if (this.mode === 'single') {
+ if (n !== this.cur) this.showPage(n);
+ this.scroller.scrollTop = atEnd ? this.scroller.scrollHeight : 0;
+ } else this.scrollToPage(n);
+ this.updateBar();
+ }
+
+ /** Einzelansicht: nur Seite `n` sichtbar. Einpassen danach, weil erst jetzt der Kopf dieser Seite messbar ist. */
+ private showPage(n: number): void {
+ this.cur = Math.min(Math.max(1, n), Math.max(1, this.pages.length));
+ for (const p of this.pages) p.wrap.hidden = p.n !== this.cur;
+ this.layout();
+ this.scroller.scrollTop = 0;
+ this.scroller.scrollLeft = 0;
+ }
+
+ private scrollToPage(n: number): void {
+ const p = this.pages[n - 1];
+ if (!p) return;
+ this.scroller.scrollTop = Math.max(0, p.wrap.offsetTop - PAD);
+ this.forced = { n, top: this.scroller.scrollTop };
+ this.updatePageNo();
+ }
+
+ /**
+ * Tasten der Einzelansicht: Bild auf/ab blättert am Rand der Seite (vorher scrollt es wie gewohnt), Pfeile links/rechts
+ * immer, Pfeile hoch/runter nur, wenn die Seite ganz zu sehen ist. Zoom mit Strg in beiden Ansichten.
+ */
+ private onKey(e: KeyboardEvent): void {
+ const t = e.target as HTMLElement | null;
+ if (t?.closest('input, textarea, select, [contenteditable=""], [contenteditable=true]')) return;
+ if (e.ctrlKey && !e.altKey) {
+ if (e.key === '+' || e.key === '=') { e.preventDefault(); this.step(1); }
+ else if (e.key === '-') { e.preventDefault(); this.step(-1); }
+ else if (e.key === '0') { e.preventDefault(); this.setZoom(null); }
+ return;
+ }
+ if (this.mode !== 'single' || e.altKey || e.metaKey || e.shiftKey || !this.pages.length) return;
+ const sc = this.scroller;
+ const fits = sc.scrollHeight <= sc.clientHeight + 1;
+ const atTop = sc.scrollTop <= 1, atBottom = sc.scrollTop + sc.clientHeight >= sc.scrollHeight - 1;
+ const n = this.cur;
+ let to = 0, atEnd = false;
+ switch (e.key) {
+ case 'ArrowLeft': to = n - 1; break;
+ case 'ArrowRight': to = n + 1; break;
+ case 'ArrowUp': if (fits) to = n - 1; break;
+ case 'ArrowDown': if (fits) to = n + 1; break;
+ case 'PageUp': if (atTop) { to = n - 1; atEnd = true; } break;
+ case 'PageDown': if (atBottom) to = n + 1; break;
+ case 'Home': to = 1; break;
+ case 'End': to = this.pages.length; break;
+ default: return;
+ }
+ if (!to) return;
+ e.preventDefault();
+ if (to >= 1 && to <= this.pages.length && to !== n) this.go(to, atEnd);
+ }
+
+ private toggleThumbs(): void {
+ this.thumbsPref = this.thumbsEl.hidden;
+ this.savePrefs();
+ this.updateThumbs();
+ }
+
+ /** Vorschauleiste nach Wunsch, aber nur, wenn die Ansicht breit genug ist. */
+ private updateThumbs(): void {
+ const width = this.root.clientWidth;
+ const want = this.thumbsPref ?? this.pages.length > 1;
+ const narrow = width > 0 && width < THUMBS_MIN_VIEW;
+ const show = want && !narrow && this.pages.length > 0;
+ // Versteckter Reiter (Breite 0): so lassen, wie es ist, bis er wieder zu sehen ist
+ if (width > 0 && this.thumbsEl.hidden === show) this.thumbsEl.hidden = !show;
+ const b = this.bar.thumbs;
+ b.setAttribute('aria-pressed', String(!this.thumbsEl.hidden));
+ b.disabled = narrow || !this.pages.length;
+ b.title = narrow ? 'Page thumbnails (the view is too narrow)' : 'Page thumbnails';
+ if (!this.thumbsEl.hidden) this.markThumb(this.pages[this.currentPage() - 1]);
+ }
+
+ private async renderThumb(p: Page | undefined): Promise<void> {
+ if (!p || p.thumbDone || !p.src.doc || this.thumbsEl.hidden) return;
+ p.thumbDone = true;
+ let page: PDFPageProxy;
+ try { page = await p.src.doc.getPage(p.pin); } catch { return; }
+ if (p.dead) return;
+ const base = page.getViewport({ scale: 1 });
+ const dpr = window.devicePixelRatio || 1;
+ const vp = page.getViewport({ scale: THUMB_W * dpr / base.width });
+ const c = el('canvas', { width: Math.max(1, Math.round(vp.width)), height: Math.max(1, Math.round(vp.height)) });
+ const g = c.getContext('2d')!;
+ g.fillStyle = '#fff';
+ g.fillRect(0, 0, c.width, c.height);
+ try { await page.render({ canvas: c, canvasContext: g, viewport: vp }).promise; } catch { return; }
+ if (p.dead) return;
+ p.thumbImg.style.height = `${Math.round(THUMB_W * base.height / base.width)}px`;
+ p.thumbImg.replaceChildren(c);
+ }
+
+ /** Aktuelle Seite in der Leiste orange und in Sicht halten (nur die Leiste scrollt, nie das Fenster). */
+ private markThumb(p: Page | undefined): void {
+ for (const x of this.thumbsEl.querySelectorAll('.pdf-thumb.on')) if (x !== p?.thumb) { x.classList.remove('on'); x.removeAttribute('aria-current'); }
+ if (!p) return;
+ p.thumb.classList.add('on');
+ p.thumb.setAttribute('aria-current', 'page');
+ const s = this.thumbsEl, t = p.thumb;
+ if (s.hidden || !s.clientHeight) return;
+ if (t.offsetTop < s.scrollTop) s.scrollTop = t.offsetTop - 8;
+ else if (t.offsetTop + t.offsetHeight > s.scrollTop + s.clientHeight) s.scrollTop = t.offsetTop + t.offsetHeight - s.clientHeight + 8;
+ }
+
+ private savePrefs(): void {
+ const v: Prefs = { mode: this.mode, fit: this.fit };
+ if (this.thumbsPref != null) v.thumbs = this.thumbsPref;
+ try { localStorage.setItem(`soma.pdf.${this.kind}`, JSON.stringify(v)); } catch { /* ohne Speicher geht es auch */ }
}
// ---- Zoom und Seiten --------------------------------------------------------------------------------------------
@@ -245,58 +673,93 @@ export class PdfView {
if (next) this.setZoom(next);
}
+ private setFit(f: Fit): void {
+ this.fit = f;
+ this.savePrefs();
+ this.setZoom(null);
+ }
+
private setZoom(z: number | null): void {
- const p = this.currentPage();
+ const n = this.currentPage();
this.zoom = z;
this.layout();
- this.pages[p - 1]?.box.scrollIntoView({ block: 'start' });
+ if (this.mode === 'all') this.scrollToPage(n);
this.updateBar();
}
- /** Maßstab: 1 heißt 100 % (72 PDF-Punkte = 96 CSS-Pixel wie im Browser). */
- private scale(): number { return this.zoom ?? this.fitScale; }
+ /** Maßstab der aktuellen Seite: 1 heißt 100 % (72 PDF-Punkte = 96 CSS-Pixel wie im Browser). */
+ private scale(): number {
+ const p = this.pages[this.currentPage() - 1];
+ return p ? this.scaleOf(p) : this.zoom ?? 1;
+ }
+
+ /**
+ * Seitenbreite: alle Seiten im selben Maßstab, die breiteste passt (ein A4 neben einem A3 bleibt kleiner, wie auf dem
+ * Tisch). Ganze Seite: jede Seite für sich, samt Kopf, damit gemischte Formate je Blatt ganz zu sehen sind.
+ */
+ private scaleOf(p: Page): number {
+ if (this.zoom != null) return this.zoom;
+ const aw = Math.max(120, this.viewW - 2 * PAD) / CSS_UNITS;
+ if (this.fit === 'page') {
+ const ah = Math.max(80, this.viewH - 2 * PAD - p.headH) / CSS_UNITS;
+ return Math.min(aw / p.size[0], ah / p.size[1]);
+ }
+ return aw / this.maxW;
+ }
private relayoutSoon(): void {
clearTimeout(this.relayoutTimer);
- this.relayoutTimer = setTimeout(() => { this.layout(); this.updateBar(); }, 120);
+ this.relayoutTimer = setTimeout(() => {
+ const n = this.currentPage();
+ this.layout();
+ if (this.mode === 'all' && this.fit === 'page' && this.zoom == null) this.scrollToPage(n);
+ this.updateBar();
+ }, 120);
}
/** Setzt die Seitengrößen für den aktuellen Maßstab. Gezeichnete Seiten mit altem Maßstab werden beim Sichtbarwerden neu gezeichnet. */
private layout(): void {
- this.lastWidth = this.scroller.clientWidth;
- const avail = Math.max(120, this.lastWidth - 32);
- this.fitScale = avail / (this.pageSize[0] * CSS_UNITS);
- const s = this.scale();
+ this.viewW = this.scroller.clientWidth;
+ this.viewH = this.scroller.clientHeight;
for (const p of this.pages) {
- const [w, h] = p.box.dataset.w ? [Number(p.box.dataset.w), Number(p.box.dataset.h)] : this.pageSize;
- p.box.style.width = `${Math.floor(w * CSS_UNITS * s)}px`;
- p.box.style.height = `${Math.floor(h * CSS_UNITS * s)}px`;
+ // Kopf messen, solange er zu sehen ist (in der Einzelansicht nur bei der gezeigten Seite)
+ if (!p.wrap.hidden && p.wrap.firstElementChild !== p.box && p.wrap.offsetHeight) p.headH = p.wrap.offsetHeight - p.box.offsetHeight;
+ const s = this.scaleOf(p);
+ const w = Math.floor(p.size[0] * CSS_UNITS * s);
+ p.box.style.width = `${w}px`;
+ p.box.style.height = `${Math.floor(p.size[1] * CSS_UNITS * s)}px`;
+ p.wrap.style.width = `${w}px`;
if (p.scale && Math.abs(p.scale - s) > 0.001) this.unrender(p);
}
// Sichtbare Seiten gleich neu zeichnen, der Beobachter meldet nur Wechsel der Sichtbarkeit
const r = this.scroller.getBoundingClientRect();
for (const p of this.pages) {
+ if (p.wrap.hidden) continue;
const b = p.box.getBoundingClientRect();
if (b.bottom > r.top - 600 && b.top < r.bottom + 600) void this.renderPage(p);
}
}
private async renderPage(p: Page | undefined): Promise<void> {
- if (!p || !this.doc) return;
- const s = this.scale();
+ if (!p || p.dead || !p.src.doc || p.wrap.hidden) return;
+ let s = this.scaleOf(p);
if (p.scale && Math.abs(p.scale - s) < 0.001) return;
this.unrender(p);
p.scale = s;
- const doc = this.doc;
let page: PDFPageProxy;
- try { page = await doc.getPage(p.n); } catch { return; }
- if (doc !== this.doc || p.scale !== s) return;
+ try { page = await p.src.doc.getPage(p.pin); } catch { return; }
+ if (p.dead || p.scale !== s) return;
const base = page.getViewport({ scale: 1 });
- p.box.dataset.w = String(base.width);
- p.box.dataset.h = String(base.height);
+ if (Math.abs(base.width - p.size[0]) > 0.5 || Math.abs(base.height - p.size[1]) > 0.5) {
+ // Format war nur angenommen (sehr dicke Datei): jetzt das echte, die breiteste Seite kann sich dadurch ändern
+ p.size = [base.width, base.height];
+ if (base.width > this.maxW) { this.maxW = base.width; this.relayoutSoon(); }
+ s = p.scale = this.scaleOf(p);
+ }
const vp = page.getViewport({ scale: s * CSS_UNITS });
p.box.style.width = `${Math.floor(vp.width)}px`;
p.box.style.height = `${Math.floor(vp.height)}px`;
+ p.wrap.style.width = `${Math.floor(vp.width)}px`;
const dpr = window.devicePixelRatio || 1;
const canvas = el('canvas', { className: 'pdf-canvas', width: Math.floor(vp.width * dpr), height: Math.floor(vp.height * dpr) });
const text = el('div', { className: 'textLayer' });
@@ -304,7 +767,9 @@ export class PdfView {
p.box.style.setProperty('--total-scale-factor', String(vp.scale));
p.canvas = canvas;
p.text = text;
- p.box.append(canvas, text);
+ // Vor eine Überlagerung des Decorators, damit sie obenauf bleibt (z-index regelt es auch, die Reihenfolge hilft beim Lesen)
+ const over = p.box.querySelector(':scope > .pdf-overlay');
+ if (over) over.before(canvas, text); else p.box.append(canvas, text);
p.task = page.render({ canvas, canvasContext: canvas.getContext('2d')!, viewport: vp, transform: dpr !== 1 ? [dpr, 0, 0, dpr, 0, 0] : undefined });
try { await p.task.promise; } catch { return; } // abgebrochen (neuer Maßstab) oder kaputte Seite: Rest der PDF bleibt nutzbar
finally { p.task = null; }
@@ -324,35 +789,64 @@ export class PdfView {
}
private clearPages(): void {
- for (const p of this.pages) { this.observer.unobserve(p.box); this.unrender(p); }
+ for (const p of this.pages) { p.dead = true; this.observer.unobserve(p.box); this.thumbObserver.unobserve(p.thumb); this.unrender(p); }
this.pages = [];
+ this.lastCur = null;
+ this.forced = null;
this.pagesEl.replaceChildren();
+ this.thumbsEl.replaceChildren();
}
private showMessage(text: string): void {
this.clearPages();
+ this.destroyDocs(new Set());
+ this.srcs = [];
+ this.isEmpty = false;
this.pagesEl.append(el('div', { className: 'pdf-msg', textContent: text }));
+ this.updateThumbs();
this.updateBar();
}
private updatePageNo(): void {
- this.bar.page.textContent = this.pages.length ? `Page ${this.currentPage()} of ${this.pages.length}` : '';
+ const n = this.currentPage(), count = this.pages.length;
+ this.bar.page.textContent = count ? `Page ${n} of ${count}` : '';
+ this.bar.prev.disabled = n <= 1;
+ this.bar.next.disabled = n >= count;
+ const p = this.pages[n - 1] ?? null;
+ if (p === this.lastCur) return;
+ this.lastCur = p;
+ this.markThumb(p ?? undefined);
+ this.bar.mark.disabled = !p?.src.doc;
+ if (p) this.decorate(() => this.deco.current?.(p.src.key, p.pin));
}
private updateBar(): void {
this.updatePageNo();
+ const single = this.mode === 'single';
+ this.bar.prev.hidden = this.bar.next.hidden = !single;
+ for (const b of this.bar.mode.querySelectorAll<HTMLElement>('[data-v]')) b.setAttribute('aria-checked', String(b.dataset.v === this.mode));
+ for (const b of this.bar.fit.querySelectorAll<HTMLElement>('[data-v]')) b.setAttribute('aria-checked', String(this.zoom == null && b.dataset.v === this.fit));
this.bar.zoom.textContent = `${Math.round(this.scale() * 100)}%`;
- this.bar.mark.disabled = !this.pages.length;
+ this.bar.mark.disabled = !this.pages[this.currentPage() - 1]?.src.doc;
this.bar.quote.disabled = !this.selection();
}
// ---- Prüfhilfen (nur für Tests) ---------------------------------------------------------------------------------
state() {
+ const cur = this.currentPage();
return {
- pages: this.pages.length, rendered: this.pages.filter((p) => p.canvas && !p.task).map((p) => p.n), current: this.currentPage(),
- zoom: Math.round(this.scale() * 100), error: this.error, float: !this.floatBtn.hidden,
+ pages: this.pages.length, rendered: this.pages.filter((p) => p.canvas && !p.task).map((p) => p.n), current: cur,
+ zoom: Math.round(this.scale() * 100), error: this.error, quote: !this.bar.quote.disabled,
text: this.pages.map((p) => p.text?.textContent ?? null),
+ mode: this.mode, fit: this.zoom == null ? this.fit : null,
+ visible: this.pages.filter((p) => !p.wrap.hidden).map((p) => p.n),
+ thumbs: {
+ visible: !this.thumbsEl.hidden, count: this.thumbsEl.childElementCount,
+ rendered: this.pages.filter((p) => p.thumbImg.querySelector('canvas')).length,
+ current: Number(this.thumbsEl.querySelector<HTMLElement>('.pdf-thumb.on')?.dataset.page ?? 0),
+ },
+ src: this.pages.map((p) => ({ key: p.src.key, page: p.pin, error: p.src.error })),
};
}
@@ -381,6 +875,23 @@ export class PdfView {
/** PDF-Punkte zu CSS-Pixeln (72 zu 96 dpi), wie im Browser bei 100 %. */
const CSS_UNITS = 96 / 72;
+/**
+ * Formate aller Seiten je Datei in PDF-Punkten. Bei sehr vielen Seiten nur das der ersten Seite je Datei (siehe
+ * SIZE_ALL_MAX), die übrigen kommen beim Zeichnen. Unlesbare Datei: ein Platzhalter im Querformat.
+ */
+async function readSizes(srcs: Src[]): Promise<[number, number][][]> {
+ const total = srcs.reduce((a, s) => a + s.count, 0);
+ const sizeOf = async (doc: PDFDocumentProxy, n: number): Promise<[number, number]> => {
+ try { const vp = (await doc.getPage(n)).getViewport({ scale: 1 }); return [vp.width, vp.height]; } catch { return [595, 842]; }
+ };
+ return Promise.all(srcs.map(async (s) => {
+ if (!s.doc) return [ERR_SIZE];
+ const doc = s.doc;
+ if (total > SIZE_ALL_MAX) { const first = await sizeOf(doc, 1); return Array.from({ length: s.count }, () => first); }
+ return Promise.all(Array.from({ length: s.count }, (_, i) => sizeOf(doc, i + 1)));
+ }));
+}
+
/** Zitat als eine Zeile: Zeilenumbrüche der PDF und Silbentrennung am Zeilenende fallen weg. */
export function cleanQuote(s: string): string {
return s.replace(/(\p{L})-\s*\n\s*(\p{Ll})/gu, '$1$2').replace(/\s+/g, ' ').trim();
diff --git a/app/src/renderer/sectiontool.ts b/app/src/renderer/sectiontool.ts
index 74f64dc..106011b 100644
--- a/app/src/renderer/sectiontool.ts
+++ b/app/src/renderer/sectiontool.ts
@@ -46,7 +46,7 @@ export class SectionTool {
private value = 0;
private flipped = false;
/** Fläche, an der der Schnitt ausgerichtet ist. `normal` zeigt aus dem Material heraus, `base` ist ihre Lage entlang der Normalen. */
- private face: { normal: number[]; point: number[]; name: string; base: number } | null = null;
+ private face: { normal: number[]; point: number[]; name: string; base: number; drawing?: boolean } | null = null;
private range: [number, number] = [0, 1];
private picking = false;
private note = '';
@@ -102,6 +102,33 @@ export class SectionTool {
this.render();
}
+ /**
+ * Schnitt wie in einer Zeichnung (E76): Ebene durch `point`, weggenommen wird die Seite, in die `removed` zeigt. `name`
+ * nennt die Herkunft („section A-A of Bracket“). Danach ist es ein gewöhnlicher Schnitt an einer Fläche: Tiefe und Seite
+ * lassen sich verstellen.
+ */
+ showPlane(point: number[], removed: number[], name: string): void {
+ const len = Math.hypot(removed[0], removed[1], removed[2]);
+ if (!(len > 1e-9)) return;
+ this.stopPick();
+ const n = removed.map((x) => x / len);
+ this.axis = 'face';
+ this.flipped = false;
+ this.note = '';
+ this.face = { normal: n, point: [...point], name, base: dot(n, point), drawing: true };
+ if (!this.active) {
+ this.active = true;
+ this.ui.button.setAttribute('aria-pressed', 'true');
+ this.ui.card.hidden = false;
+ }
+ this.updateRange();
+ this.value = this.face.base;
+ this.apply();
+ }
+
+ /** Stammt der Schnitt aus einer Zeichnung? */
+ get fromDrawing(): boolean { return this.active && this.axis === 'face' && !!this.face?.drawing; }
+
/** Neues Modell (Build oder anderer Stand): Bereich neu bestimmen, die Ebene bleibt, wo sie war. */
refresh(): void {
if (!this.active) return;
@@ -119,6 +146,7 @@ export class SectionTool {
}
const r = this.removedDir();
const p = this.planePoint();
+ if (this.face!.drawing) return `section view as ${this.face!.name}, plane through (${p.map(f3).join(', ')}) mm, the side towards ${vec(r)} is cut away`;
return `section view, plane through (${p.map(f3).join(', ')}) mm parallel to a face of "${this.face!.name}", `
+ `the side towards ${vec(r)} is cut away`;
}
@@ -254,6 +282,7 @@ export class SectionTool {
ui.range.disabled = ui.value.disabled = this.picking;
let hint: string;
if (this.picking) hint = this.note || 'Click a planar face in the model. Escape cancels.';
+ else if (faceMode && this.face!.drawing) hint = `As ${this.face!.name}, depth from its cutting plane.`;
else if (faceMode) hint = `Parallel to a face of “${this.face!.name}”, depth from the face.`;
else hint = `Cut away: ${this.axis.toUpperCase()} ${this.removedSign() > 0 ? '>' : '<'} ${num(this.value)} mm`;
ui.hint.textContent = hint;
diff --git a/app/src/renderer/style.css b/app/src/renderer/style.css
index 223426e..7abe5c2 100644
--- a/app/src/renderer/style.css
+++ b/app/src/renderer/style.css
@@ -279,21 +279,50 @@ code { font-family:var(--mono); font-size:.95em; }
.codeview .hint { color:var(--tx3); padding:14px; }
/* PDF-Ansicht (E54): Seiten auf dunklem Grund, Textebene von pdf.js darüber (unsichtbarer Text, nur zum Markieren) */
-.pdfview { position:absolute; inset:0; display:flex; flex-direction:column; font-family:var(--sans); }
-.pdf-bar { display:flex; align-items:center; gap:2px; flex-shrink:0; padding:4px 8px 4px 14px; border-bottom:1px solid var(--line); background:var(--term); font:12px var(--sans); }
+.pdfview { position:absolute; inset:0; display:flex; flex-direction:column; font-family:var(--sans); container:pdfview / inline-size; }
+.pdf-bar { display:flex; align-items:center; gap:2px; flex-shrink:0; min-width:0; padding:4px 8px 4px 8px; border-bottom:1px solid var(--line); background:var(--term); font:12px var(--sans); }
.pdf-bar .btn { height:24px; }
+.pdf-bar .btn.ico { padding:0 5px; }
.pdf-bar .btn:disabled { opacity:.45; }
-.pdf-zoom { min-width:44px; text-align:center; }
-.pdf-sep { width:1px; height:16px; background:var(--line2); margin:0 6px; }
+.pdf-bar .btn[aria-pressed=true] { background:var(--acc-tint); color:var(--acc-tx); box-shadow:inset 0 0 0 1px var(--acc-line); }
+.pdf-bar .pdf-seg { margin:0 2px; }
+.pdf-bar .pdf-seg button { width:26px; }
+.pdf-zoom { min-width:44px; text-align:center; font-variant-numeric:tabular-nums; }
+.pdf-page-no { padding:0 6px; white-space:nowrap; font-variant-numeric:tabular-nums; }
+.pdf-sep { width:1px; height:16px; background:var(--line2); margin:0 6px; flex-shrink:0; }
+/* Schmale Ansicht: Knöpfe nur noch als Symbol, ganz schmal auch ohne Prozentanzeige */
+@container pdfview (max-width: 640px) { .pdf-bar .lbl { display:none; } .pdf-bar .btn { padding:0 5px; } }
+@container pdfview (max-width: 470px) { .pdf-zoom { display:none; } .pdf-sep { margin:0 3px; } }
+.pdf-body { flex:1; min-height:0; display:flex; }
+/* Vorschauleiste: schmal, eigene Scrollleiste, aktuelle Seite orange umrandet */
+.pdf-thumbs { width:118px; flex-shrink:0; position:relative; overflow:hidden auto; scrollbar-width:thin; display:flex; flex-direction:column; align-items:center; gap:6px; padding:10px 0 16px; background:var(--term); border-right:1px solid var(--line); }
+.pdf-thumb { display:flex; flex-direction:column; align-items:center; gap:5px; width:104px; padding:6px 4px 4px; border-radius:6px; flex-shrink:0; }
+.pdf-thumb:hover { background:var(--s2); }
+.pdf-thumb-img { width:84px; flex-shrink:0; background:#fff; box-shadow:0 1px 4px rgba(0,0,0,.5); display:flex; align-items:center; justify-content:center; overflow:hidden; }
+.pdf-thumb-img canvas { display:block; width:100%; height:100%; }
+.pdf-thumb-img.err { background:var(--s2); color:var(--err); box-shadow:inset 0 0 0 1px rgba(240,116,112,.45); }
+.pdf-thumb-label { max-width:96px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; font:11px/1.3 var(--sans); color:var(--tx3); }
+.pdf-thumb.on .pdf-thumb-img { box-shadow:0 0 0 2px var(--acc); }
+.pdf-thumb.on .pdf-thumb-label { color:var(--acc-tx); font-weight:500; }
/* Platz für die Scrollleiste immer frei: Sonst wird die Breite beim Erscheinen der Leiste schmaler, die Seiten werden neu
eingepasst und neu gezeichnet, und eine Textauswahl ginge verloren */
-.pdf-scroll { flex:1; min-height:0; overflow:auto; scrollbar-gutter:stable; outline:none; background:var(--bg); }
+.pdf-scroll { position:relative; flex:1; min-width:0; min-height:0; overflow:auto; scrollbar-gutter:stable; outline:none; background:var(--bg); }
.pdf-pages { display:flex; flex-direction:column; align-items:center; gap:14px; padding:16px; width:max-content; min-width:100%; box-sizing:border-box; }
-.pdf-page { position:relative; background:#fff; box-shadow:0 2px 10px rgba(0,0,0,.45); --scale-round-x:1px; --scale-round-y:1px; }
+/* Einzelansicht: die Seite mittig, wenn sie kleiner als die Ansicht ist */
+.pdfview.single .pdf-pages { min-height:100%; justify-content:center; }
+/* Hülle je Seite: Kopf des Decorators (gleich breit wie die Seite) über der Seite */
+.pdf-sheet { display:flex; flex-direction:column; gap:6px; flex-shrink:0; }
+.pdf-page { position:relative; flex-shrink:0; background:#fff; box-shadow:0 2px 10px rgba(0,0,0,.45); --scale-round-x:1px; --scale-round-y:1px; }
.pdf-page .pdf-canvas { position:absolute; inset:0; width:100%; height:100%; }
.pdf-page .pdf-pnum { position:absolute; left:-30px; top:0; font:11px var(--mono); color:var(--tx3); }
+/* Überlagerung des Decorators über Leinwand und Textebene: selbst ohne Mauswirkung, damit Text markierbar bleibt */
+.pdf-overlay { position:absolute; inset:0; z-index:2; pointer-events:none; }
+.pdf-page.pdf-errpage { background:var(--s2); box-shadow:inset 0 0 0 1px rgba(240,116,112,.45); display:flex; align-items:center; justify-content:center; }
+.pdf-errpage-msg { display:flex; align-items:flex-start; gap:10px; max-width:min(80%, 520px); color:var(--tx2); font:13px/1.5 var(--sans); overflow-wrap:anywhere; }
+.pdf-errpage-msg svg.ic, .pdf-err svg.ic { color:var(--err); margin-top:1px; }
+.pdf-err { display:flex; align-items:flex-start; gap:9px; width:min(100%, 560px); padding:9px 12px; border-radius:6px; background:var(--err-tint); color:var(--tx2); font:13px/1.5 var(--sans); overflow-wrap:anywhere; }
+.pdf-err b { color:var(--tx); font-weight:500; }
.pdf-msg { color:var(--tx2); padding:20px; max-width:420px; font:13px/1.5 var(--sans); }
-.pdf-float { position:absolute; z-index:5; height:26px; font:500 12px var(--sans); box-shadow:var(--shadow); }
/* DXF-Ansicht (E80): Leiste wie bei der PDF, darunter eine Zeichenfläche auf dem Grund der App (wie der Modellbereich im CAD) */
.dxfview { position:absolute; inset:0; display:flex; flex-direction:column; font-family:var(--sans); }
@@ -1141,3 +1170,55 @@ code { font-family:var(--mono); font-size:.95em; }
.ask-msg { font-size:14px; font-weight:500; white-space:pre-wrap; overflow-wrap:anywhere; }
.ask-detail { color:var(--tx2); white-space:pre-wrap; overflow-wrap:anywhere; max-height:40vh; overflow:auto; }
.ask-btns { display:flex; flex-wrap:wrap; justify-content:flex-end; gap:8px; margin-top:8px; }
+
+/* Dokument „Drawings“ (E76, drawings.ts): alle Blätter in der PDF-Ansicht, Kopf je Blatt, Ansichten und Maße anklickbar */
+.ctab.pane { font-family:var(--sans); }
+.ctab.pane svg { color:var(--tx3); }
+.ctab.pane.on svg { color:var(--acc-tx); }
+.dwview { position:absolute; inset:0; display:flex; flex-direction:column; font-family:var(--sans); }
+.dw-bar { display:flex; align-items:center; gap:8px; flex-shrink:0; height:30px; padding:0 8px 0 14px; border-bottom:1px solid var(--line); background:var(--s1); font-size:12px; color:var(--tx2); }
+.dw-bar b { color:var(--tx); font-weight:500; }
+.dw-bar .btn { height:22px; }
+.dw-status.warn { color:var(--warn); }
+.dw-pdf { position:relative; flex:1; min-height:0; }
+.dwview.dw-pointer .pdf-page { cursor:pointer; }
+.dw-head { display:flex; flex-direction:column; gap:4px; padding:0 0 6px; font-size:12px; color:var(--tx2); }
+.dw-hrow { display:flex; align-items:center; gap:8px; min-width:0; }
+.dw-name { color:var(--tx); font-weight:500; font-size:13px; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
+.dw-hrow .m { white-space:nowrap; color:var(--tx3); }
+.dw-hrow .tag { font-size:11px; padding:1px 7px; border-radius:9px; white-space:nowrap; }
+.dw-hrow .tag.w { background:rgba(232,197,71,.12); color:var(--warn); }
+.dw-hrow .btn-tag:hover { background:rgba(232,197,71,.22); }
+.dw-hrow .ibtn { color:var(--tx3); }
+.dw-warns { display:flex; flex-direction:column; gap:2px; padding:6px 8px; border:1px solid var(--line2); border-radius:8px; background:var(--s1); }
+.dw-warn { display:flex; align-items:flex-start; gap:8px; padding:4px 6px; border-radius:5px; text-align:left; color:var(--tx2); font-size:12px; line-height:1.4; }
+.dw-warn:hover { background:var(--s3); color:var(--tx); }
+.dw-warn svg { color:var(--warn); flex-shrink:0; margin-top:2px; }
+.dw-warn .c3 { margin-left:auto; white-space:nowrap; font-family:var(--mono); font-size:11px; }
+/* Ebene über dem Blatt: Klicks gehen an die Textebene darunter, die Treffer rechnet drawings.ts aus dem Index */
+.dw-ov { position:absolute; inset:0; pointer-events:none; }
+.dw-hit { position:absolute; box-sizing:border-box; border-radius:3px; }
+.dw-hit.hov { border:1.5px dashed var(--acc); background:rgba(242,154,56,.06); }
+.dw-hit.sel { border:2px solid var(--acc); background:rgba(242,154,56,.10); }
+.dw-hit.flash { border:2px solid var(--warn); background:rgba(232,197,71,.15); }
+.dw-tag { position:absolute; left:-2px; bottom:100%; margin-bottom:3px; padding:1px 7px; border-radius:5px; background:rgba(24,27,31,.94); color:var(--tx); font:500 11px var(--sans); white-space:nowrap; box-shadow:0 2px 8px rgba(0,0,0,.35); }
+.dw-hit.sel .dw-tag { background:var(--acc); color:#1a1206; }
+.dw-hit.below .dw-tag { bottom:auto; top:100%; margin:3px 0 0; }
+.dw-wmark { position:absolute; box-sizing:border-box; border:1.5px dotted var(--warn); border-radius:3px; }
+.dw-card { position:absolute; left:12px; right:12px; bottom:12px; z-index:6; max-width:440px; margin:0 auto; display:flex; flex-direction:column; gap:8px; padding:10px 10px 10px 14px; border:1px solid var(--line2); border-radius:10px; background:var(--s1); box-shadow:var(--shadow); font-size:12px; }
+.dw-chead { display:flex; align-items:flex-start; gap:8px; }
+.dw-chead > div { flex:1; min-width:0; }
+.dw-chead .t { font-size:14px; font-weight:500; color:var(--tx); }
+.dw-chead .m { color:var(--tx3); overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+.dw-cline { display:flex; gap:8px; align-items:flex-start; color:var(--tx2); line-height:1.4; }
+.dw-cline svg { flex-shrink:0; margin-top:1px; color:var(--tx3); }
+.dw-cline.warn svg { color:var(--warn); }
+.dw-cacts { display:flex; align-items:center; gap:8px; }
+.dw-empty { max-width:360px; margin:60px auto; display:flex; flex-direction:column; align-items:center; gap:8px; text-align:center; color:var(--tx2); font-size:13px; line-height:1.5; }
+.dw-empty .ic { color:var(--tx3); }
+.dw-empty b { color:var(--tx); font-weight:500; font-size:14px; }
+.dw-empty p { margin:0; }
+.dw-note { display:flex; align-items:center; gap:10px; flex-shrink:0; padding:8px 10px 8px 14px; border-bottom:1px solid var(--line); background:rgba(232,197,71,.08); color:var(--tx); font-size:12px; line-height:1.4; }
+.dw-note > svg { color:var(--warn); flex-shrink:0; }
+.dw-note span { flex:1; }
+.dw-note .btn { flex-shrink:0; }
diff --git a/app/src/renderer/viewer.ts b/app/src/renderer/viewer.ts
index 67a012f..5d6ebfc 100644
--- a/app/src/renderer/viewer.ts
+++ b/app/src/renderer/viewer.ts
@@ -559,6 +559,18 @@ export class Viewer {
this.requestRender();
}
+ /** Blick aus `dir0` auf eine Kugel um `center` mit `radius` (mm), etwa die Einzelheit einer Zeichnung. */
+ frame(dir0: THREE.Vector3, center: THREE.Vector3, radius: number): void {
+ if (dir0.lengthSq() < 1e-18 || !(radius > 0)) return;
+ const dir = dir0.clone().normalize();
+ if (Math.abs(dir.z) > 0.99999) dir.set(0, -0.0001, Math.sign(dir.z)).normalize();
+ this.anim?.stop();
+ this.placeAt(center, dir, radius / Math.sin(THREE.MathUtils.degToRad(this.persp.fov / 2)) * 1.05);
+ this.controls.update();
+ this.fitClip();
+ this.requestRender();
+ }
+
// ---- Kamera, Projektion und Maus (E81) -------------------------------------------------------------------------
/** tan des halben Bildwinkels: Höhe in der Ebene des Drehpunkts je Abstand. */
diff --git a/app/src/shared/types.ts b/app/src/shared/types.ts
index 4d4b3b3..c264819 100644
--- a/app/src/shared/types.ts
+++ b/app/src/shared/types.ts
@@ -290,6 +290,44 @@ export interface AnimFileError { file: string; line: number | null; message: str
export interface AnimList { animations: AnimEntry[]; errors: AnimFileError[]; building: boolean }
export interface AnimBuildResult extends AnimList { ok: boolean; error?: string }
+/**
+ * Technische Zeichnungen (E76) aus .soma/drawings/index.json. Blattmaße in mm ab der linken unteren Papierecke, Punkte und
+ * Richtungen im Modell (mm, Z oben) wie im Viewer. Die Felder ab Index-Version 2 fehlen bei älteren Builds.
+ */
+export interface DrawingView {
+ name: string; kind: string; scale: string; line: number | null; file: string | null;
+ /** Vom Teil zum Betrachter. */
+ direction: number[];
+ /** Lage auf dem Blatt [x0, y0, x1, y1]. */
+ bbox: number[];
+ parts?: string[]; right?: number[]; up?: number[]; center?: number[]; size?: number;
+ /** Schnitt: Ebene durch `point`, `normal` zeigt zur weggenommenen Seite (zum Betrachter). Stufenschnitte ohne Ebene. */
+ section?: { kind: string; point?: number[]; normal?: number[] };
+ detail?: { center: number[]; radius: number; parent: string };
+}
+export interface DrawingDim {
+ kind: string; value: number; label: string; view: string; line: number | null; file: string | null;
+ points?: number[][]; radius?: number | null;
+ /** Maß mit Linien und Text auf dem Blatt, und nur der Text. */
+ box?: number[]; textBox?: number[];
+}
+export interface DrawingWarning { message: string; file: string | null; line: number | null; box?: number[] }
+export interface DrawingEntry {
+ id: string; name: string; file: string | null; line: number | null;
+ size: string; width: number; height: number; scale: string;
+ pdf: string; dxf: string | null;
+ /** Was die PDF-Seite vom Blatt zeigt, falls nicht genau das Papier. */
+ pageBox: number[];
+ views: DrawingView[]; dims: DrawingDim[]; warnings: DrawingWarning[];
+ /** Zeitpunkt der PDF (ms), Modell oder Zeichnungsdatei neuer: veraltet. */
+ built: number; stale: boolean;
+ /** Mit Teilen, Achsen und Maßpunkten gebaut (Index ab Version 2)? Sonst kennt die App nur die Lage der Ansichten. */
+ linked: boolean;
+}
+export interface DrawingFileError { file: string; line: number | null; message: string }
+export interface DrawingList { drawings: DrawingEntry[]; errors: DrawingFileError[]; building: boolean }
+export interface DrawingBuildResult extends DrawingList { ok: boolean; error?: string }
+
/** Ergebnis einer Auswertung (`soma analyze`, E58), Metadaten aus extras.soma_result der GLB. */
export interface ResultPart {
name: string; group: string | null; area: number; critical: number; min?: number; max?: number;
@@ -519,6 +557,16 @@ export interface SomaApi {
build(file?: string): Promise<AnimBuildResult>;
onChanged(cb: () => void): void;
};
+ /** Technische Zeichnungen (E76): Liste aus .soma/drawings/index.json, bauen über `soma drawing build`. */
+ drawings: {
+ list(): Promise<DrawingList>;
+ /** `file` (drawings/x.py) baut nur diese Datei, ohne alle. */
+ build(file?: string): Promise<DrawingBuildResult>;
+ /** Exportieren mit Dateidialog: alle Blätter als eine PDF, je Blatt PDF/DXF/beides in einen Ordner, mit `sheet` (id) nur dieses Blatt. */
+ export(what: 'set' | 'pdf' | 'dxf' | 'both', sheet?: string): Promise<ExportResult>;
+ /** Index neu geschrieben, Zeichnungsdatei geändert oder Bauen begonnen. */
+ onChanged(cb: () => void): void;
+ };
/** Ergebnisse von `soma analyze` (E58). */
results: {
list(): Promise<ResultEntry[]>;
diff --git a/app/test/drawview.mjs b/app/test/drawview.mjs
new file mode 100644
index 0000000..6160eac
--- /dev/null
+++ b/app/test/drawview.mjs
@@ -0,0 +1,219 @@
+// Test für das Dokument „Drawings“ (E76): Der Knopf an der Leiste öffnet alle Blätter in der Code-Spalte (keine Seitenleiste),
+// leer mit Hinweis, nach `soma drawing build` mit Kopf je Blatt. Zeiger über einer Ansicht hebt sie hervor, ein Klick dreht
+// die Kamera in ihre Blickrichtung, ein Schnitt setzt das Schnittwerkzeug auf seine Ebene, ein Maß zeigt seine Punkte und
+// die Maßzahl im Bild. Escape hebt alles auf. Ändert sich das Modell, heißt das Blatt „older than the code“, ein neues Blatt
+// gibt dem Knopf einen Punkt, solange das Dokument nicht vorne steht.
+// Aufruf: npm run build, dann node test/drawview.mjs. SMOKE_VISIBLE=offscreen SMOKE_SHOTS=1 legt Bilder ab.
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { APP, checker, cleanup, sleep, startApp } from './harness.mjs';
+
+const t = checker();
+const { check } = t;
+let app;
+
+const PY = process.env.SOMA_PYTHON || path.join(process.env.LOCALAPPDATA ?? '', 'soma-dev', 'venv', 'Scripts', 'python.exe');
+const soma = (dir, ...args) => spawnSync(PY, ['-m', 'soma', ...args, '--project', dir], { encoding: 'utf8', env: { ...process.env, PYTHONUTF8: '1', PYTHONIOENCODING: 'utf-8' } });
+
+const MODEL = `import cadquery as cq
+from soma import add_part
+
+plate = (cq.Workplane("XY").box(120, 60, 12, centered=(True, True, False))
+ .faces(">Z").workplane().rarray(90, 35, 2, 2).hole(8))
+add_part("Plate", plate)
+add_part("Pin", cq.Workplane("XY").circle(5).extrude(30).translate((0, 0, -9)))
+`;
+
+// Vorne, Draufsicht, Schnitt A-A von links und eine Einzelheit, Maße in mehreren Ansichten
+const SHEET = `from soma.drawing import Sheet
+
+sh = Sheet("Plate", size="A3", scale="1:2")
+front = sh.view("Plate", "front", at=(140, 200))
+top = sh.view("Plate", "top", at=(140, 110))
+cut = sh.section(["Plate", "Pin"], "left", through=(0, 0, 0), at=(300, 200), name="A", parent=front)
+det = sh.detail(front, (45, 0, 12), 6, at=(320, 90), scale="5:1", name="B")
+front.dim((-60, 0, 0), (60, 0, 0), offset=-12)
+front.dim((60, 0, 0), (60, 0, 12), offset=10)
+top.diameter((45, 17.5, 12), 4, angle=45, text="4x <>")
+`;
+
+/** Bildschirmpunkt der Mitte eines Rechtecks [x0, y0, x1, y1] (Blatt-mm). */
+const mid = (b) => [(b[0] + b[2]) / 2, (b[1] + b[3]) / 2];
+
+try {
+ app = await startApp({ name: 'drawview' });
+ const { ev, waitFor } = app;
+ await waitFor('Projekt und Build', () => !!window.__t && !!window.__t.project() && window.__t.status().state === 'ok');
+ const proj = await ev(() => window.__t.project());
+ fs.writeFileSync(path.join(proj.dir, 'model.py'), MODEL);
+ await waitFor('Modell gebaut', () => window.__t.status().state === 'ok' && window.__t.partCount() === 2, 90000).catch(() => {});
+
+ // 1) Leer: Knopf öffnet das Dokument in der Code-Spalte, eine offene Seitenleiste geht zu
+ await ev(() => window.__t.showPanel('files'));
+ await ev(() => document.getElementById('btn-rail-drawings').click());
+ await waitFor('Dokument offen', () => window.__t.editor.state().pane === 'soma:drawings', 5000).catch(() => {});
+ const lay = await ev(() => ({ ...window.__t.layout(), pressed: document.getElementById('btn-rail-drawings').getAttribute('aria-pressed'), empty: document.querySelector('.dw-empty')?.textContent ?? null }));
+ check('Leiste öffnet „Drawings“ in der Code-Spalte, ohne Seitenleiste, Knopf gedrückt', lay.code && !lay.side && lay.pressed === 'true', JSON.stringify(lay));
+ check('Ohne Zeichnungen: Hinweis, wie man den Agenten fragt', /No drawings yet/.test(lay.empty ?? '') && /drawings\/\*\.py/.test(lay.empty ?? ''), lay.empty);
+
+ // 2) Gebaut aus dem Terminal (wie der Agent): Das Dokument zieht von selbst nach
+ fs.mkdirSync(path.join(proj.dir, 'drawings'), { recursive: true });
+ fs.writeFileSync(path.join(proj.dir, 'drawings', 'plate.py'), SHEET);
+ const b = soma(proj.dir, 'drawing', 'build');
+ check('soma drawing build im Projekt', b.status === 0, (b.stderr || b.stdout).slice(-300));
+ await waitFor('Blatt im Dokument', () => (window.__t.drawings()?.sheets.length ?? 0) === 1 && (window.__t.drawings()?.pdf.pages ?? 0) >= 1, 20000).catch(() => {});
+ let st = await ev(() => window.__t.drawings());
+ check('Ein Blatt mit Kopf: Name, Format, Maßstab, Ansichten und Maße', st?.heads.length === 1 && /Plate/.test(st.heads[0]) && /A3/.test(st.heads[0]) && /1:2/.test(st.heads[0]) && /4 views/.test(st.heads[0]) && /3 dimensions/.test(st.heads[0]), JSON.stringify(st?.heads));
+ check('Knopf ohne Punkt, solange das Dokument vorne steht', !(await ev(() => window.__t.rail().drawings)));
+ await waitFor('Seite gezeichnet', () => (window.__t.drawings()?.pdf.rendered ?? []).length > 0, 20000).catch(() => {});
+
+ // Index lesen, um die Ziele auf dem Blatt zu finden
+ const idx = JSON.parse(fs.readFileSync(path.join(proj.dir, '.soma', 'drawings', 'index.json'), 'utf8')).drawings[0];
+ const view = (n) => idx.views.find((v) => v.name === n);
+ const at = async (x, y) => ev(([x, y]) => window.__t.drawingsScreen('Plate', x, y), [x, y]);
+ const move = (p) => ev(({ x, y }) => {
+ const target = document.elementFromPoint(x, y);
+ target?.dispatchEvent(new PointerEvent('pointermove', { clientX: x, clientY: y, bubbles: true, buttons: 0 }));
+ return target?.closest('.pdf-page') ? true : target?.className ?? null;
+ }, p);
+ const click = async (p) => { await app.page.click(p.x, p.y); await sleep(150); };
+
+ // 3) Zeiger über der Vorderansicht (zwischen den Maßen, auf der Platte)
+ const fp = await at(...mid(view('front').bbox));
+ const onPage = await move(fp);
+ await sleep(100);
+ st = await ev(() => window.__t.drawings());
+ check('Zeiger über der Vorderansicht hebt sie hervor', onPage === true && /front/.test(st?.hover ?? ''), `${JSON.stringify(onPage)} ${st?.hover}`);
+
+ // 4) Klick: Kamera schaut von vorne (-Y)
+ await click(fp);
+ await waitFor('Kamera steht', () => !window.__t.viewer.viewState().animating, 5000).catch(() => {});
+ let vs = await ev(() => window.__t.viewer.viewState());
+ st = await ev(() => window.__t.drawings());
+ const ghost = await ev(() => window.__t.viewer.partLook(window.__t.viewer.partList().find((p) => p.name === 'Pin').id));
+ check('Ansicht zeigt nur die Platte: der Stift ist durchsichtig', !!ghost && ghost.opacity < 0.9, JSON.stringify(ghost));
+ check('Klick auf die Vorderansicht: Auswahl, Karte, Kamera von vorne', /front/.test(st?.selected?.label ?? '') && /View front/.test(st?.card ?? '') && vs.dir[1] < -0.99, `${JSON.stringify(st?.selected)} dir=${vs.dir.map((x) => x.toFixed(2))}`);
+
+ // 5) Schnitt A-A: Schnittwerkzeug mit derselben Ebene (von links gesehen, -X weggenommen)
+ const cp = await at(...mid(view('A-A').bbox));
+ await click(cp);
+ const sec = await ev(() => window.__t.section());
+ vs = await ev(() => window.__t.viewer.viewState());
+ check('Klick auf den Schnitt: Schnittwerkzeug auf seiner Ebene, Kamera von links', sec.active && sec.axis === 'face' && sec.face?.normal[0] < -0.99 && Math.abs(sec.value) < 1e-6 && vs.dir[0] < -0.99,
+ `${JSON.stringify({ active: sec.active, axis: sec.axis, n: sec.face?.normal, v: sec.value })} dir=${vs.dir.map((x) => x.toFixed(2))}`);
+ check('Schnitt nennt die Zeichnung (Karte des Werkzeugs, Text für den Agenten)', /A-A/.test(sec.agent ?? '') && /Plate/.test(sec.agent ?? ''), sec.agent);
+
+ // 6) Maß 120: Punkte und Maßzahl im Bild, der Schnitt der Zeichnung geht wieder weg
+ const dim = idx.dims.find((d) => d.label === '120');
+ const dp = await at(...mid(dim.text_box ?? dim.box));
+ await click(dp);
+ const marks = await ev(() => ({ labels: [...document.querySelectorAll('.v-label')].map((x) => x.textContent), pts: document.querySelectorAll('.v-pt').length }));
+ st = await ev(() => window.__t.drawings());
+ check('Klick auf ein Maß: Maßzahl und zwei Punkte im Bild', marks.labels.includes('120') && marks.pts === 2 && /measured 120 mm/.test(st?.card ?? ''), JSON.stringify(marks) + ' ' + st?.card);
+ check('Schnitt aus der Zeichnung wieder aus', !(await ev(() => window.__t.section().active)));
+
+ // 7) Durchmesser in der Draufsicht: Kreis um den Mittelpunkt
+ const dd = idx.dims.find((d) => d.kind === 'diameter');
+ await click(await at(...mid(dd.text_box ?? dd.box)));
+ const dl = await ev(() => [...document.querySelectorAll('.v-label')].map((x) => x.textContent));
+ check('Durchmesser: Maßzahl im Bild', dl.some((x) => /Ø8/.test(x)), JSON.stringify(dl));
+ if (process.env.SMOKE_SHOTS) {
+ fs.mkdirSync(path.join(APP, 'test', 'shots'), { recursive: true });
+ await sleep(800);
+ await app.screenshot(path.join(APP, 'test', 'shots', '30-drawings.png')).catch((e) => console.log('Screenshot:', e.message));
+ }
+
+ // 8) Escape: Auswahl und Marken weg
+ await ev(() => document.querySelector('.dwview .pdf-scroll')?.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true })));
+ await sleep(100);
+ st = await ev(() => window.__t.drawings());
+ const left = await ev(() => document.querySelectorAll('.v-label').length);
+ const look = await ev(() => window.__t.viewer.partLook(window.__t.viewer.partList().find((p) => p.name === 'Pin').id));
+ check('Escape hebt Auswahl und Marken auf, alle Teile wieder normal', !st?.selected && st?.card === null && left === 0 && look?.opacity === 1, `${JSON.stringify(st?.selected)} labels=${left} ${JSON.stringify(look)}`);
+
+ // 9) Einzelheit: Kamera rückt heran (Abstand deutlich kleiner als bei der Ansicht)
+ await click(fp);
+ const far = (await ev(() => window.__t.viewer.viewState())).dist;
+ await click(await at(...mid(view('B').bbox)));
+ const near = (await ev(() => window.__t.viewer.viewState())).dist;
+ check('Klick auf die Einzelheit: Kamera rückt heran', near < far * 0.4, `${far.toFixed(1)} -> ${near.toFixed(1)}`);
+ await ev(() => window.__t.drawingsSelectNone());
+
+ // 10) Modell geändert: Blatt veraltet
+ fs.appendFileSync(path.join(proj.dir, 'model.py'), '# geändert\n');
+ // Dateiänderungen frischen die offenen Reiter auf, auch das Dokument
+ await waitFor('veraltet', () => window.__t.drawings()?.sheets[0]?.stale === true, 10000).catch(() => {});
+ st = await ev(() => window.__t.drawings());
+ check('Geändertes Modell: Blatt „older than the code“', st?.sheets[0]?.stale === true && /older than the code/.test(st.heads[0] ?? ''), JSON.stringify(st?.heads));
+
+ // 11) Neues Blatt, während das Dokument nicht vorne steht: Punkt am Knopf
+ await waitFor('Modell neu gebaut', () => window.__t.status().state === 'ok', 90000).catch(() => {});
+ await ev(() => window.__t.openCode('model.py'));
+ fs.writeFileSync(path.join(proj.dir, 'drawings', 'second.py'), 'from soma.drawing import Sheet\nsh = Sheet("Second", size="A4", scale="1:2")\nsh.view("Pin", "front", at=(105, 150))\n');
+ const b2 = soma(proj.dir, 'drawing', 'build', 'drawings/second.py');
+ check('Zweites Blatt gebaut', b2.status === 0, (b2.stderr || b2.stdout).slice(-300));
+ await waitFor('Punkt am Knopf', () => window.__t.rail().drawings, 15000).catch(() => {});
+ check('Neues Blatt: Punkt am Knopf „Drawings“', await ev(() => window.__t.rail().drawings));
+ await ev(() => document.getElementById('btn-rail-drawings').click());
+ await waitFor('zwei Blätter', () => (window.__t.drawings()?.sheets.length ?? 0) === 2 && !window.__t.rail().drawings, 15000).catch(() => {});
+ st = await ev(() => window.__t.drawings());
+ check('Dokument zeigt beide Blätter, der Punkt ist weg', st?.sheets.length === 2 && st.pdf.pages >= 2 && !(await ev(() => window.__t.rail().drawings)), JSON.stringify(st?.sheets));
+
+ // 11b) Export: alle Blätter als eine PDF, je Blatt PDF und DXF in einen Ordner, ein Blatt als DXF
+ const out = fs.mkdtempSync(path.join(os.tmpdir(), 'soma-drawexport-'));
+ const menu = () => ev(() => [...document.querySelectorAll('#menu-ctx:not([hidden]) .mi')].map((x) => x.textContent));
+ await ev(() => [...document.querySelectorAll('.dw-bar button')].find((b) => /Export/.test(b.textContent)).click());
+ const items = await menu();
+ check('Export-Menü oben: eine PDF, je Blatt PDF, DXF, beides', items.length === 4 && /one PDF/.test(items[0]) && /DXF/.test(items[2]), JSON.stringify(items));
+ await app.answers([path.join(out, 'set.pdf')]);
+ await ev(() => [...document.querySelectorAll('#menu-ctx .mi')][0].click());
+ await waitFor('Sammel-PDF', () => /Exported/.test(window.__t.toast().text ?? ''), 10000).catch(() => {});
+ const setPdf = path.join(out, 'set.pdf');
+ check('Alle Blätter als eine PDF exportiert (Kopie von output/drawings.pdf)', fs.existsSync(setPdf) && fs.readFileSync(setPdf).equals(fs.readFileSync(path.join(proj.dir, 'output', 'drawings.pdf'))), (await ev(() => window.__t.toast().text)) ?? '');
+ const dirOut = path.join(out, 'folder');
+ fs.mkdirSync(dirOut);
+ await app.answers([dirOut]);
+ await ev(() => [...document.querySelectorAll('.dw-bar button')].find((b) => /Export/.test(b.textContent)).click());
+ await ev(() => [...document.querySelectorAll('#menu-ctx .mi')][3].click());
+ await waitFor('Ordner', () => /4 files exported/.test(window.__t.toast().text ?? ''), 10000).catch(() => {});
+ const files = fs.readdirSync(dirOut).sort();
+ const toastText = (await ev(() => window.__t.toast().text)) ?? '';
+ check('PDF und DXF je Blatt im Ordner, Hinweis auf das veraltete Blatt', JSON.stringify(files) === JSON.stringify(['Plate.dxf', 'Plate.pdf', 'Second.dxf', 'Second.pdf']) && /Older than the code: Plate/.test(toastText), `${JSON.stringify(files)} ${toastText}`);
+ await app.answers([path.join(out, 'second.dxf')]);
+ await ev(() => [...document.querySelectorAll('.dw-head')].find((h) => /Second/.test(h.textContent)).querySelector('button[aria-label^="Export"]').click());
+ const sheetItems = await menu();
+ await ev(() => [...document.querySelectorAll('#menu-ctx .mi')][1].click());
+ await waitFor('Blatt-DXF', () => /Exported/.test(window.__t.toast().text ?? ''), 10000).catch(() => {});
+ check('Export je Blatt im Kopf: PDF oder DXF, DXF in die gewählte Datei', JSON.stringify(sheetItems) === JSON.stringify(['PDF …', 'DXF …']) && fs.existsSync(path.join(out, 'second.dxf')), JSON.stringify(sheetItems));
+ cleanup(out);
+
+ // 12) Index eines älteren soma (Version 1): Hinweis mit Rebuild, die Karte sagt, was fehlt
+ const ip = path.join(proj.dir, '.soma', 'drawings', 'index.json');
+ const old = JSON.parse(fs.readFileSync(ip, 'utf8'));
+ fs.writeFileSync(ip, JSON.stringify({ ...old, version: 1 }));
+ await waitFor('Hinweis älteres soma', () => !document.querySelector('.dw-note')?.hidden, 10000).catch(() => {});
+ const note = await ev(() => { const n = document.querySelector('.dw-note'); return n && !n.hidden ? n.textContent : null; });
+ check('Älterer Index: Hinweis „Built with an older soma“ mit Rebuild', /older soma/.test(note ?? '') && /Rebuild/.test(note ?? ''), note);
+ await ev(() => window.__t.drawingsGoTo('Plate'));
+ await sleep(300);
+ await click(await at(...mid(view('front').bbox)));
+ st = await ev(() => window.__t.drawings());
+ check('Älterer Index: Karte erklärt, dass erst ein Neubau verknüpft', /older soma/.test(st?.card ?? ''), st?.card);
+ await ev(() => window.__t.drawingsSelectNone());
+ fs.writeFileSync(ip, JSON.stringify(old));
+
+ // 13) Zweiter Klick auf den Knopf schließt die Code-Spalte
+ await ev(() => document.getElementById('btn-rail-drawings').click());
+ check('Knopf bei vorne stehendem Dokument: Code-Spalte zu', !(await ev(() => window.__t.layout().code)));
+
+ const relevant = app.page.errors.filter((e) => !/favicon/i.test(e));
+ check('Keine Konsolenfehler im Renderer', relevant.length === 0, relevant.slice(0, 2).join(' | ').slice(0, 200));
+} catch (e) {
+ console.log('ABBRUCH:', e.message);
+ t.fail();
+}
+if (app) { await app.stop(); cleanup(app.ud); }
+console.log(t.fails ? `\n${t.fails} Prüfung(en) fehlgeschlagen` : '\nALLE PRÜFUNGEN BESTANDEN');
+process.exit(t.fails ? 1 : 0);
diff --git a/app/test/editor.mjs b/app/test/editor.mjs
index 7c0b8ec..23d665a 100644
--- a/app/test/editor.mjs
+++ b/app/test/editor.mjs
@@ -226,8 +226,9 @@ try {
await ev(() => { const tm = window.__t.terminals; const orig = tm.insert.bind(tm); tm.insert = (x) => { window.__inserted = x; return orig(x); }; });
const selected = await ev(() => window.__t.editor.pdfSelect(1, 'Haltemoment 0,45 Nm'));
await sleep(100);
- check('Text markiert: schwebender Knopf „Zitat an Agent" erscheint', selected && (await ed()).pdf.float);
- await ev(() => document.querySelector('.pdf-float').click());
+ const qb = await ev(() => { const b = [...document.querySelectorAll('.pdfview:not([hidden]) .pdf-bar button')].find((x) => /Quote to agent/.test(x.textContent)); return b ? { on: !b.disabled, acc: b.classList.contains('acc') } : null; });
+ check('Text markiert: Knopf „Quote to agent“ oben aktiv und orange, kein schwebender Knopf am Text', selected && (await ed()).pdf.quote && qb?.on && qb.acc && !(await ev(() => document.querySelector('.pdf-float'))), JSON.stringify(qb));
+ await ev(() => [...document.querySelectorAll('.pdfview:not([hidden]) .pdf-bar button')].find((x) => /Quote to agent/.test(x.textContent)).click());
await sleep(200);
check('Zitat geht mit Datei und Seite an den Agenten', await ev(() => window.__inserted) === '[Quote: docs/datenblatt.pdf p. 1: "Haltemoment 0,45 Nm"] ',
`${await ev(() => window.__inserted)} | ${(await ev(() => window.__t.toast())).text} | ${await ev(() => window.__t.terminals.count)}`);
@@ -242,6 +243,57 @@ try {
check('PDF auf der Platte geändert (etwa vom Agenten): Ansicht lädt neu', (await ed()).pdf?.pages === 3);
await ev(() => window.__t.editor.pdfSelect(1, 'Datenblatt'));
await shot('9c-pdf');
+
+ // 9c2) PDF: Vorschauleiste, Einzelseite mit Blättern, ganze Seite einpassen (gemerkt je Art der Ansicht)
+ const pv = (sel) => ev((q) => { const r = [...document.querySelectorAll('.pdfview')].find((v) => !v.hidden); const e = q ? r?.querySelector(q) : r; e?.click(); return !!e; }, sel);
+ const pkey = (key) => ev((k) => { const sc = [...document.querySelectorAll('.pdfview')].find((v) => !v.hidden).querySelector('.pdf-scroll'); sc.focus(); sc.dispatchEvent(new KeyboardEvent('keydown', { key: k, bubbles: true, cancelable: true })); }, key);
+ await waitFor('Vorschaubilder', () => (window.__t.editor.state().pdf?.thumbs.rendered ?? 0) >= 3, 15000).catch(() => {});
+ s = await ed();
+ check('Vorschauleiste: bei mehreren Seiten sichtbar, 3 Bilder gezeichnet, Seite 1 orange', s.pdf.thumbs.visible && s.pdf.thumbs.count === 3 && s.pdf.thumbs.rendered === 3 && s.pdf.thumbs.current === 1,
+ JSON.stringify(s.pdf.thumbs));
+ await pv('.pdf-thumb[data-page="3"]');
+ await sleep(150);
+ s = await ed();
+ check('Klick auf das dritte Vorschaubild springt zu Seite 3', s.pdf.current === 3 && s.pdf.thumbs.current === 3
+ && await ev(() => [...document.querySelectorAll('.pdfview')].find((v) => !v.hidden).querySelector('.pdf-page-no').textContent === 'Page 3 of 3'), JSON.stringify([s.pdf.current, s.pdf.thumbs]));
+ await pv('[data-pdf="mode"] [data-v="single"]');
+ await sleep(150);
+ s = await ed();
+ check('Einzelseite: nur Seite 3 zu sehen, Knöpfe zum Blättern da', s.pdf.mode === 'single' && JSON.stringify(s.pdf.visible) === '[3]'
+ && await ev(() => { const r = [...document.querySelectorAll('.pdfview')].find((v) => !v.hidden); return !r.querySelector('[data-pdf="prev"]').hidden && r.querySelector('[data-pdf="next"]').disabled; }), JSON.stringify(s.pdf.visible));
+ const nav = [];
+ await pkey('ArrowLeft'); nav.push((await ed()).pdf.visible.join());
+ await pkey('PageUp'); nav.push((await ed()).pdf.visible.join());
+ await pkey('End'); nav.push((await ed()).pdf.visible.join());
+ await pv('[data-pdf="prev"]'); nav.push((await ed()).pdf.visible.join());
+ await pkey('Home'); nav.push((await ed()).pdf.visible.join());
+ await pkey('ArrowRight'); nav.push((await ed()).pdf.visible.join());
+ check('Blättern mit Pfeil, Bild auf, Ende, Knopf, Pos1, Pfeil: 2, 1, 3, 2, 1, 2', nav.join(' ') === '2 1 3 2 1 2', nav.join(' '));
+ await waitFor('Seite 2 gezeichnet', () => window.__t.editor.state().pdf?.rendered.includes(2), 10000).catch(() => {});
+ check('Einzelseite: die gezeigte Seite ist gezeichnet, Text darauf', (await ed()).pdf.text[1]?.includes('Seite zwei'));
+ await pv('[data-pdf="fit"] [data-v="page"]');
+ await waitFor('neu gezeichnet', () => window.__t.editor.state().pdf?.rendered.includes(2), 10000).catch(() => {});
+ const fits = () => ev(() => {
+ const r = [...document.querySelectorAll('.pdfview')].find((v) => !v.hidden);
+ const sc = r.querySelector('.pdf-scroll'), cur = window.__t.editor.state().pdf.current;
+ const a = sc.getBoundingClientRect(), b = r.querySelector(`.pdf-page[data-page="${cur}"]`).getBoundingClientRect();
+ return { inside: b.top >= a.top - 1 && b.bottom <= a.top + sc.clientHeight + 1 && b.left >= a.left - 1 && b.right <= a.left + sc.clientWidth + 1, h: Math.round(b.height), view: sc.clientHeight, w: Math.round(b.width), vw: sc.clientWidth, scroll: sc.scrollHeight - sc.clientHeight };
+ });
+ let f = await fits();
+ s = await ed();
+ check('„Fit whole page": Seite ganz zu sehen, füllt Höhe oder Breite, nichts zu scrollen', s.pdf.fit === 'page' && f.inside && (f.h > f.view - 60 || f.w > f.vw - 60) && f.scroll <= 1, JSON.stringify(f));
+ await shot('9e-pdf-einzelseite');
+ await pv('[data-pdf="mode"] [data-v="all"]');
+ await sleep(200);
+ f = await fits();
+ s = await ed();
+ check('Zurück zu allen Seiten: Seite 2 bleibt die aktuelle und ist ganz zu sehen', s.pdf.mode === 'all' && JSON.stringify(s.pdf.visible) === '[1,2,3]' && s.pdf.current === 2 && f.inside, JSON.stringify([s.pdf.current, f]));
+ await pv('[data-pdf="thumbs"]');
+ s = await ed();
+ const saved = await ev(() => localStorage.getItem('soma.pdf.pdf'));
+ check('Leiste ausgeschaltet, Wahl gemerkt (Ansicht, Einpassen, Leiste)', !s.pdf.thumbs.visible && saved === '{"mode":"all","fit":"page","thumbs":false}', saved);
+ await pv('[data-pdf="thumbs"]');
+ await pv('[data-pdf="fit"] [data-v="width"]');
fs.writeFileSync(path.join(proj.dir, 'docs', 'kaputt.pdf'), '%PDF-1.4 kein echtes PDF');
await open('docs/kaputt.pdf');
await waitFor('Fehlermeldung', () => !!window.__t.editor.state().pdf?.error, 10000).catch(() => {});
diff --git a/app/test/helpshots-spec.mjs b/app/test/helpshots-spec.mjs
index 472c32d..8e2754a 100644
--- a/app/test/helpshots-spec.mjs
+++ b/app/test/helpshots-spec.mjs
@@ -93,6 +93,7 @@ export const SHOTS = [
{ label: 'Files', sel: '#rail [data-panel=files]', at: 'r' },
{ label: 'Analysis', sel: '#rail [data-panel=analysis]', at: 'r' },
{ label: 'Animation', sel: '#rail [data-panel=anim]', at: 'r' },
+ { label: 'Drawings', sel: '#btn-rail-drawings', at: 'r' },
{ label: 'Skills', sel: '#rail [data-panel=skills]', at: 'r' },
{ label: 'Help', sel: '#btn-help', at: 'r' },
{ label: 'Settings', sel: '#btn-settings', at: 'r' },
diff --git a/app/test/run-all.mjs b/app/test/run-all.mjs
index b657630..a1a50a6 100644
--- a/app/test/run-all.mjs
+++ b/app/test/run-all.mjs
@@ -9,7 +9,7 @@ import path from 'node:path';
const DIR = import.meta.dirname;
// Längste zuerst, damit sie nicht am Ende allein laufen
-const ALL = ['animation', 'fem', 'versions', 'smoke', 'editor', 'skills', 'params', 'explode', 'fasteners', 'drawing', 'section', 'measure', 'groups', 'dxf', 'packages', 'settings', 'tutorial', 'buildlock', 'unit'];
+const ALL = ['animation', 'fem', 'versions', 'smoke', 'editor', 'skills', 'params', 'explode', 'fasteners', 'drawing', 'drawview', 'section', 'measure', 'groups', 'dxf', 'packages', 'settings', 'tutorial', 'buildlock', 'unit'];
const wanted = process.argv.slice(2);
const unknown = wanted.filter((s) => !ALL.includes(s));
if (unknown.length) { console.log(`Unbekannte Suite: ${unknown.join(', ')}. Vorhanden: ${ALL.join(', ')}`); process.exit(2); }