Agent Zero
402 lines
16 KiB
TypeScript
402 lines
16 KiB
TypeScript
/**
|
||
* core-annotate – Built-in V2-Plugin (Task A4.4).
|
||
*
|
||
* Werkzeuge: text (Platzierung — Inhalt via InlineTextEditor/PropertiesPanel,
|
||
* Bestandskanal onTextEdit bleibt), dimension (2-Punkt linear), leader
|
||
* (2-Punkt Pfeil+Label).
|
||
*/
|
||
import type { PluginV2, ToolExtensionV2, FullToolContext } from '../../types';
|
||
import {
|
||
DEFAULT_DIM_STYLE, getDimStyle, computeDimValue, formatDimValue,
|
||
} from '../../../services/dimStyleService';
|
||
import type { CADElement } from '../../../types/cad.types';
|
||
import type { Pt } from '../../../tools/modification/geometry';
|
||
|
||
const uid = (prefix: string): string =>
|
||
`${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 9)}`;
|
||
|
||
/** Gemeinsamer 2-Punkt-Sitzungsstart für dimension/leader. */
|
||
let twoPointStart: Pt | null = null;
|
||
|
||
function optsOf(ctx: FullToolContext): { stroke: string; layerId: string } {
|
||
return {
|
||
stroke: (ctx.options.strokeColor as string | undefined) ?? '#e0e0e0',
|
||
layerId: (ctx.options.layerId as string | undefined) ?? 'layer-0',
|
||
};
|
||
}
|
||
|
||
function buildDimension(start: Pt, end: Pt, ctx: FullToolContext): CADElement {
|
||
const o = optsOf(ctx);
|
||
return {
|
||
id: uid('dim'),
|
||
type: 'dimension',
|
||
layerId: o.layerId,
|
||
x: (start.x + end.x) / 2,
|
||
y: (start.y + end.y) / 2,
|
||
width: Math.hypot(end.x - start.x, end.y - start.y), // Legacy: dist als Breite
|
||
height: 20,
|
||
properties: { x1: start.x, y1: start.y, x2: end.x, y2: end.y },
|
||
} as unknown as CADElement;
|
||
}
|
||
|
||
function buildLeader(start: Pt, end: Pt, ctx: FullToolContext): CADElement {
|
||
const o = optsOf(ctx);
|
||
return {
|
||
id: uid('leader'),
|
||
type: 'leader',
|
||
layerId: o.layerId,
|
||
x: end.x,
|
||
y: end.y,
|
||
width: Math.abs(end.x - start.x),
|
||
height: Math.abs(end.y - start.y),
|
||
properties: { x1: start.x, y1: start.y, x2: end.x, y2: end.y, text: '', fontSize: 12, stroke: o.stroke, strokeWidth: 1 },
|
||
} as unknown as CADElement;
|
||
}
|
||
|
||
/** Generischer 2-Punkt-Annotate-Fluss (down→Preview→up commit). */
|
||
function make2PointAnnotate(
|
||
id: 'dimension' | 'leader',
|
||
label: string,
|
||
icon: string,
|
||
build: (a: Pt, b: Pt, ctx: FullToolContext) => CADElement,
|
||
): ToolExtensionV2 {
|
||
return {
|
||
manifest: { id, label, icon, ribbonTab: 'format', tags: ['basic'] },
|
||
optionsSchema: [{ key: 'strokeColor', label: 'Farbe', type: 'color' }],
|
||
handlers: {
|
||
down(e, ctx) {
|
||
twoPointStart = e.world;
|
||
ctx.setStatus(`${label}: Startpunkt gesetzt – Ende wählen`);
|
||
},
|
||
move(e, ctx) {
|
||
if (!twoPointStart) return;
|
||
ctx.setPreview?.(build(twoPointStart, e.world, ctx as FullToolContext));
|
||
},
|
||
up(e, ctx) {
|
||
const c = ctx as FullToolContext;
|
||
if (!twoPointStart || !c.doc) { twoPointStart = null; return; }
|
||
const el = build(twoPointStart, e.world, c);
|
||
c.doc.transact(() => c.doc!.addElement(el));
|
||
twoPointStart = null;
|
||
ctx.setPreview?.(null);
|
||
ctx.setStatus(`${label} erstellt (${el.id})`);
|
||
},
|
||
cancel(ctx) {
|
||
twoPointStart = null;
|
||
ctx.setPreview?.(null);
|
||
ctx.setStatus(`${label} abgebrochen`);
|
||
},
|
||
},
|
||
};
|
||
}
|
||
|
||
/**
|
||
* text-Werkzeug (A4.4): Klick platziert Textelement mit leerem Inhalt;
|
||
* Bearbeitung läuft über den bestehenden InlineTextEditor/onTextEdit-Kanal.
|
||
*/
|
||
export const textTool: ToolExtensionV2 = {
|
||
manifest: {
|
||
id: 'text',
|
||
label: 'Text',
|
||
icon: 'T',
|
||
ribbonTab: 'format',
|
||
tags: ['basic'],
|
||
description: 'Text platzieren und über Editor beschriften',
|
||
},
|
||
optionsSchema: [{ key: 'fontSize', label: 'Größe', type: 'number', min: 6, max: 72 }],
|
||
handlers: {
|
||
down(e, ctx) {
|
||
const c = ctx as FullToolContext;
|
||
if (!c.doc) return;
|
||
const layerId = (c.options.layerId as string | undefined) ?? 'layer-0';
|
||
const fontSize = (c.options.fontSize as number | undefined) ?? 12;
|
||
const el = {
|
||
id: uid('text'),
|
||
type: 'text',
|
||
layerId,
|
||
x: e.world.x,
|
||
y: e.world.y,
|
||
width: 100,
|
||
height: 20,
|
||
properties: { text: '', fontSize },
|
||
} as unknown as CADElement;
|
||
c.doc.transact(() => c.doc!.addElement(el));
|
||
ctx.setStatus(`Text platziert (${el.id}) – now via Editor`);
|
||
},
|
||
},
|
||
};
|
||
|
||
export const dimensionTool: ToolExtensionV2 = make2PointAnnotate('dimension', 'Bemaßung', '\u2194', buildDimension);
|
||
export const leaderTool: ToolExtensionV2 = make2PointAnnotate('leader', 'Leader', '\u21b1', buildLeader);
|
||
|
||
/** V2-Plugin: Beschriftung/Bemaßung (A4.4). */
|
||
// ─────────────────────────────────────────────────────────────
|
||
// Task D4: MTEXT — Mehrzeiliger Text mit optionalem Rahmen.
|
||
// Klick platziert Text (Inhalt aus Options, Zeilenumbrüche erhalten),
|
||
// frame-Option erzeugt ein rect in derselben Transaktion (1 Undo).
|
||
// ─────────────────────────────────────────────────────────────
|
||
|
||
export const mtextTool: ToolExtensionV2 = {
|
||
manifest: {
|
||
id: 'mtext',
|
||
label: 'Mehrzeilentext',
|
||
icon: '¶',
|
||
ribbonTab: 'format',
|
||
tags: ['basic'],
|
||
description: 'Mehrzeiligen Text platzieren (Rahmen optional, Task D4)',
|
||
},
|
||
optionsSchema: [
|
||
{ key: 'text', label: 'Text', type: 'text' },
|
||
{ key: 'fontSize', label: 'Größe', type: 'number', min: 6, max: 72 },
|
||
{ key: 'frame', label: 'Rahmen', type: 'checkbox' },
|
||
],
|
||
handlers: {
|
||
down(e, ctx) {
|
||
const c = ctx as FullToolContext;
|
||
if (!c.doc) return;
|
||
const layerId = (c.options.layerId as string | undefined) ?? 'layer-0';
|
||
const text = (c.options.text as string | undefined) ?? '';
|
||
const fontSize = (c.options.fontSize as number | undefined) ?? 12;
|
||
const frame = (c.options.frame as boolean | undefined) ?? false;
|
||
// Newline ohne Escape-Probleme: charCode 10
|
||
const NL = String.fromCharCode(10);
|
||
const lines = text.split(NL);
|
||
const lineCount = Math.max(1, lines.length);
|
||
const maxLen = lines.reduce((m, l) => Math.max(m, l.length), 0);
|
||
const textW = maxLen * fontSize * 0.6;
|
||
const textH = lineCount * fontSize * 1.4;
|
||
const els: CADElement[] = [{
|
||
id: uid('mtext'),
|
||
type: 'text',
|
||
layerId,
|
||
x: e.world.x,
|
||
y: e.world.y,
|
||
width: textW,
|
||
height: textH,
|
||
properties: { text, fontSize, mtext: true },
|
||
} as unknown as CADElement];
|
||
if (frame) {
|
||
const pad = fontSize * 0.4;
|
||
els.push({
|
||
id: uid('mtextframe'),
|
||
type: 'rect',
|
||
layerId,
|
||
x: e.world.x,
|
||
y: e.world.y,
|
||
width: textW + pad * 2,
|
||
height: textH + pad * 2,
|
||
properties: { stroke: '#9aa0a6', strokeWidth: 1, fill: 'none' },
|
||
} as unknown as CADElement);
|
||
}
|
||
c.doc.transact(() => {
|
||
for (const el of els) c.doc!.addElement(el);
|
||
});
|
||
ctx.setStatus(`Mehrzeilentext platziert (${lineCount} Zeile(n)${frame ? ', mit Rahmen' : ''})`);
|
||
},
|
||
},
|
||
};
|
||
|
||
// ─────────────────────────────────────────────────────────────
|
||
// Task CAD-1: Assoziative Bemassung — 5 Typen mit DimStyles.
|
||
// linear (H/V), aligned, angular (3 Klicks), radius, diameter.
|
||
// Alle berechnen den Masswert aus der Geometrie (assoziativ).
|
||
// ─────────────────────────────────────────────────────────────
|
||
|
||
let dimStart: Pt | null = null;
|
||
let dimVertex: Pt | null = null; // angular: Scheitel
|
||
|
||
function dimStyleOf(ctx: FullToolContext) {
|
||
const name = (ctx.options.dimStyle as string | undefined) ?? 'ISO-25';
|
||
return getDimStyle(name);
|
||
}
|
||
|
||
function commitDim(el: CADElement, ctx: FullToolContext, noun: string): void {
|
||
const c = ctx as FullToolContext;
|
||
if (!c.doc) return;
|
||
c.doc.transact(() => c.doc!.addElement(el));
|
||
ctx.setPreview?.(null);
|
||
ctx.setStatus(`${noun} erstellt: ${String(el.properties.value)}`);
|
||
}
|
||
|
||
export const dimLinearTool: ToolExtensionV2 = {
|
||
manifest: {
|
||
id: 'dim-linear', label: 'Linear-Bemassung', icon: '\u2194',
|
||
ribbonTab: 'format', tags: ['basic'],
|
||
description: 'Lineare Bemassung: 2 Punkte, horizontal/vertikal (Option)',
|
||
},
|
||
optionsSchema: [
|
||
{ key: 'dimStyle', label: 'Stil', type: 'select',
|
||
options: [{ value: 'ISO-25', label: 'ISO-25' }, { value: 'ISO-50', label: 'ISO-50' },
|
||
{ value: 'Architectural', label: 'Architektur' }, { value: 'Engineering', label: 'Engineering' }] },
|
||
{ key: 'dimSubtype', label: 'Ausrichtung', type: 'select',
|
||
options: [{ value: 'horizontal', label: 'Horizontal' }, { value: 'vertical', label: 'Vertikal' }] },
|
||
],
|
||
handlers: {
|
||
down(e, ctx) {
|
||
const c = ctx as FullToolContext;
|
||
if (!c.doc) return;
|
||
if (!dimStart) { dimStart = e.world; ctx.setStatus('Bemassung: zweiten Punkt wählen'); return; }
|
||
const subtype = (c.options.dimSubtype as string | undefined) ?? 'horizontal';
|
||
const style = dimStyleOf(c);
|
||
const raw = computeDimValue('linear', dimStart, e.world, undefined, subtype);
|
||
const el: CADElement = {
|
||
id: uid('dim'), type: 'dimension', layerId: (c.options.layerId as string | undefined) ?? 'layer-0',
|
||
x: (dimStart.x + e.world.x) / 2, y: (dimStart.y + e.world.y) / 2,
|
||
width: Math.abs(e.world.x - dimStart.x), height: Math.abs(e.world.y - dimStart.y),
|
||
properties: {
|
||
x1: dimStart.x, y1: dimStart.y, x2: e.world.x, y2: e.world.y,
|
||
dimType: 'linear', dimSubtype: subtype,
|
||
value: formatDimValue(raw, style), dimStyle: style.name,
|
||
},
|
||
} as unknown as CADElement;
|
||
dimStart = null;
|
||
commitDim(el, ctx, 'Linearbemassung');
|
||
},
|
||
move(e, ctx) {
|
||
const c = ctx as FullToolContext;
|
||
if (!dimStart) return;
|
||
const subtype = (c.options.dimSubtype as string | undefined) ?? 'horizontal';
|
||
const style = dimStyleOf(c);
|
||
const raw = computeDimValue('linear', dimStart, e.world, undefined, subtype);
|
||
ctx.setPreview?.({
|
||
id: '__preview_dim__', type: 'dimension', layerId: 'layer-0',
|
||
x: (dimStart.x + e.world.x) / 2, y: (dimStart.y + e.world.y) / 2,
|
||
width: Math.abs(e.world.x - dimStart.x), height: Math.abs(e.world.y - dimStart.y),
|
||
properties: {
|
||
x1: dimStart.x, y1: dimStart.y, x2: e.world.x, y2: e.world.y,
|
||
dimType: 'linear', dimSubtype: subtype,
|
||
value: formatDimValue(raw, style), dimStyle: style.name,
|
||
},
|
||
} as unknown as CADElement);
|
||
},
|
||
cancel(ctx) { dimStart = null; ctx.setPreview?.(null); ctx.setStatus('Bemassung abgebrochen'); },
|
||
},
|
||
};
|
||
|
||
export const dimAlignedTool: ToolExtensionV2 = {
|
||
manifest: {
|
||
id: 'dim-aligned', label: 'Ausgerichtet', icon: '\u2197',
|
||
ribbonTab: 'format', tags: ['basic'],
|
||
description: 'Bemassung entlang der Punkte-Verbindung',
|
||
},
|
||
optionsSchema: [
|
||
{ key: 'dimStyle', label: 'Stil', type: 'select',
|
||
options: [{ value: 'ISO-25', label: 'ISO-25' }, { value: 'ISO-50', label: 'ISO-50' }] },
|
||
],
|
||
handlers: {
|
||
down(e, ctx) {
|
||
const c = ctx as FullToolContext;
|
||
if (!c.doc) return;
|
||
if (!dimStart) { dimStart = e.world; ctx.setStatus('Ausgerichtet: zweiten Punkt wählen'); return; }
|
||
const style = dimStyleOf(c);
|
||
const raw = computeDimValue('aligned', dimStart, e.world);
|
||
const el: CADElement = {
|
||
id: uid('dim'), type: 'dimension', layerId: (c.options.layerId as string | undefined) ?? 'layer-0',
|
||
x: (dimStart.x + e.world.x) / 2, y: (dimStart.y + e.world.y) / 2,
|
||
width: Math.abs(e.world.x - dimStart.x), height: Math.abs(e.world.y - dimStart.y),
|
||
properties: {
|
||
x1: dimStart.x, y1: dimStart.y, x2: e.world.x, y2: e.world.y,
|
||
dimType: 'aligned', value: formatDimValue(raw, style), dimStyle: style.name,
|
||
},
|
||
} as unknown as CADElement;
|
||
dimStart = null;
|
||
commitDim(el, ctx, 'Ausgerichtete Bemassung');
|
||
},
|
||
cancel(ctx) { dimStart = null; ctx.setPreview?.(null); ctx.setStatus('Abgebrochen'); },
|
||
},
|
||
};
|
||
|
||
export const dimAngularTool: ToolExtensionV2 = {
|
||
manifest: {
|
||
id: 'dim-angular', label: 'Winkel', icon: '\u2220',
|
||
ribbonTab: 'format', tags: ['pro'],
|
||
description: 'Winkelbemassung: Scheitel, Schenkel 1, Schenkel 2',
|
||
},
|
||
optionsSchema: [
|
||
{ key: 'dimStyle', label: 'Stil', type: 'select',
|
||
options: [{ value: 'ISO-25', label: 'ISO-25' }] },
|
||
],
|
||
handlers: {
|
||
down(e, ctx) {
|
||
const c = ctx as FullToolContext;
|
||
if (!c.doc) return;
|
||
if (!dimVertex) { dimVertex = e.world; ctx.setStatus('Winkel: Schenkel 1 klicken'); return; }
|
||
if (!dimStart) { dimStart = e.world; ctx.setStatus('Winkel: Schenkel 2 klicken'); return; }
|
||
const style = dimStyleOf(c);
|
||
const leg1 = { x: dimStart.x - dimVertex.x, y: dimStart.y - dimVertex.y };
|
||
const leg2 = { x: e.world.x - dimVertex.x, y: e.world.y - dimVertex.y };
|
||
const raw = computeDimValue('angular', leg1, leg2);
|
||
const el: CADElement = {
|
||
id: uid('dim'), type: 'dimension', layerId: (c.options.layerId as string | undefined) ?? 'layer-0',
|
||
x: dimVertex.x, y: dimVertex.y, width: 0, height: 0,
|
||
properties: {
|
||
dimType: 'angular', value: formatDimValue(raw, style, 'angular'),
|
||
vertexX: dimVertex.x, vertexY: dimVertex.y,
|
||
leg1X: dimStart.x, leg1Y: dimStart.y, leg2X: e.world.x, leg2Y: e.world.y,
|
||
dimStyle: style.name,
|
||
},
|
||
} as unknown as CADElement;
|
||
dimVertex = null; dimStart = null;
|
||
commitDim(el, ctx, 'Winkelbemassung');
|
||
},
|
||
cancel(ctx) { dimVertex = null; dimStart = null; ctx.setPreview?.(null); ctx.setStatus('Abgebrochen'); },
|
||
},
|
||
};
|
||
|
||
function makeRadialDim(mode: 'radius' | 'diameter'): ToolExtensionV2 {
|
||
return {
|
||
manifest: {
|
||
id: mode === 'radius' ? 'dim-radius' : 'dim-diameter',
|
||
label: mode === 'radius' ? 'Radius' : 'Durchmesser',
|
||
icon: mode === 'radius' ? '\u2199' : '\u2300',
|
||
ribbonTab: 'format', tags: ['basic'],
|
||
description: mode === 'radius' ? 'Radius bemassen (Kreis anklicken)' : 'Durchmesser bemassen (Kreis anklicken)',
|
||
},
|
||
optionsSchema: [
|
||
{ key: 'dimStyle', label: 'Stil', type: 'select',
|
||
options: [{ value: 'ISO-25', label: 'ISO-25' }] },
|
||
],
|
||
handlers: {
|
||
down(e, ctx) {
|
||
const c = ctx as FullToolContext;
|
||
if (!c.doc || !c.selection) return;
|
||
const hit = c.selection.hitTest(e.world.x, e.world.y, 8);
|
||
if (!hit || hit.type !== 'circle') {
|
||
ctx.setStatus(`${mode === 'radius' ? 'Radius' : 'Durchmesser'}: Kreis anklicken`);
|
||
return;
|
||
}
|
||
const style = dimStyleOf(c);
|
||
const raw = computeDimValue(mode, undefined, undefined, hit);
|
||
const el: CADElement = {
|
||
id: uid('dim'), type: 'dimension', layerId: hit.layerId,
|
||
x: hit.x, y: hit.y, width: hit.width, height: hit.height,
|
||
properties: {
|
||
dimType: mode, value: formatDimValue(raw, style, mode),
|
||
centerX: hit.x, centerY: hit.y,
|
||
arrowX: hit.x + ((hit.properties as Record<string, unknown>).radius as number ?? hit.width / 2),
|
||
arrowY: hit.y,
|
||
dimStyle: style.name,
|
||
},
|
||
} as unknown as CADElement;
|
||
commitDim(el, ctx, mode === 'radius' ? 'Radiusbemassung' : 'Durchmesserbemassung');
|
||
},
|
||
},
|
||
};
|
||
}
|
||
|
||
export const dimRadiusTool: ToolExtensionV2 = makeRadialDim('radius');
|
||
export const dimDiameterTool: ToolExtensionV2 = makeRadialDim('diameter');
|
||
|
||
export const coreAnnotatePlugin: PluginV2 = {
|
||
manifest: {
|
||
id: 'core-annotate',
|
||
name: 'Beschriftung (Kern)',
|
||
version: '1.1.0',
|
||
author: 'web-cad team',
|
||
description: 'Text, Bemaßung, Leader (V2).',
|
||
category: 'tools',
|
||
enabledByDefault: true,
|
||
},
|
||
tools: [textTool, dimensionTool, leaderTool, mtextTool, dimLinearTool, dimAlignedTool, dimAngularTool, dimRadiusTool, dimDiameterTool],
|
||
};
|