feat(B07): CAD를 AutoCAD 명령 체계로 재구성한다 (조사표 1·2·3·5절)

저장소 사고로 잃은 4개 커밋(38eb7cd4·b8a11756·281528bf·f60b488d)의 작업물을 하나로 다시 담았다. 내용은 동일하다. ■ 구조 - commands/: 명령 정의(id·AutoCAD 별칭·글리프·도구/즉시실행)를 단일 소스로 두고 리본·명령행·단축키가 모두 이 레지스트리를 읽는다. tools/tool.consts.ts 폐지. - ribbon/: 탭→패널→명령 데이터(ribbon.config.ts)와 범용 렌더러 분리. AutoCAD 배치(홈·삽입·주석·뷰·출력)와 패널 확장(▾)을 따른다. - tools/factories/sequence-tool.ts: 점·숫자·문자·객체·선택 단계를 선언하면 xstate 머신을 만들어 주는 공장. 명령당 170줄 보일러플레이트 제거. - helpers/geometry/: 3점 호·정다각형·타원·스플라인·구름형·평행이동·해치 스캔선· 점렬 샘플링 등 상태 없는 순수 함수. - Toolbar 483줄을 QuickAccessBar/Ribbon/InspectorPanel/StatusBar/CommandLine/ ViewControls/PropertiesEditor/QuickProperties로 분해. ■ 명령 (조사표 기준) - 1절 그리기 21건, 2절 수정 27건, 3절 도면층·특성·그룹·유틸리티 39건 전부 반영. - 5절 주석 34건 중 26건 반영(문자·치수 16종·지시선·표·구름형·주석 축척). - HatchEntity 추가(solid·pattern·cross·gradient) + JSON 왕복, Layer에 색·선가중치· 선종류·동결·투명도 필드 추가, 그리기 루프가 동결·숨김·투명도를 반영. ■ 화면 실측에서 고친 결함 - 명령행 포커스 상태에서 ENTER가 도구로 가지 않던 문제 - 명령행 문자 입력이 접두사가 같은 명령으로 실행되던 문제 - 명령이 끝나도 입력을 계속 먹던 문제(점 입력 명령만 반복, 나머지는 선택 도구 복귀) - 시퀀스 단계 인덱스 오사용 9건 + 단계 값 종류 검사 추가 - 해치 내부를 클릭해도 선택되지 않던 문제 미반영 8건(맞춤법 검사·꺾기 치수·치수 끊기/재연관/검사 치수·기하공차·지시선 수집· 축척 리스트 편집)은 조사표 `반영` 열과 PLAN.md에 사유를 적었다.
2026-08-30 01:34:13 +09:00
parent 60bbe89edb
commit ea9d9685be
88 changed files with 8052 additions and 850 deletions
@@ -0,0 +1,66 @@
+/** 치수·지시선이 함께 쓰는 조각 만들기 (화살표·치수 문자·직전 치수 기억) */
+import { Point } from '@flatten-js/core';
+import { getDimArrowSize, getDimDecimals, getDimTextHeight } from '../../commands/dim-settings';
+import { ArrowHeadEntity } from '../../entities/ArrowHeadEntity';
+import type { Entity } from '../../entities/Entity';
+import type { MeasurementEntity } from '../../entities/MeasurementEntity';
+import { getActiveLayerId, getActiveLineColor, getScreenCanvasDrawController } from '../../state';
+import { textEntity } from '../factories/entity-factory';
+
+/** 화면 px 기준 상수를 도면 단위로 바꾼다 (줌이 달라도 크기가 일정하게 보인다) */
+export function worldFactor(): number {
+	try {
+		return getScreenCanvasDrawController().getScreenScale() || 1;
+	} catch {
+		return 1;
+	}
+}
+
+/** tip을 꼭짓점으로 하고 from 방향에서 들어오는 화살표 */
+export function arrowHead(tip: Point, from: Point, size = getDimArrowSize()): ArrowHeadEntity {
+	const length = size / worldFactor();
+	const dx = tip.x - from.x;
+	const dy = tip.y - from.y;
+	const distance = Math.hypot(dx, dy) || 1;
+	const ux = dx / distance;
+	const uy = dy / distance;
+	const baseX = tip.x - ux * length;
+	const baseY = tip.y - uy * length;
+	const halfWidth = length * 0.35;
+
+	const head = new ArrowHeadEntity(
+		getActiveLayerId(),
+		tip,
+		new Point(baseX - uy * halfWidth, baseY + ux * halfWidth),
+		new Point(baseX + uy * halfWidth, baseY - ux * halfWidth)
+	);
+	head.lineColor = getActiveLineColor();
+	head.fillColor = getActiveLineColor();
+	return head;
+}
+
+/** 치수 문자 — 설정한 소수 자릿수·문자 높이를 따른다 */
+export function dimensionText(value: number, position: Point, prefix = '', suffix = ''): Entity {
+	const label = `${prefix}${value.toFixed(getDimDecimals())}${suffix}`;
+	return textEntity(label, position, {
+		fontSize: getDimTextHeight() / worldFactor(),
+		textAlign: 'center',
+	});
+}
+
+/** 문자 그대로 찍는 주석 (좌표·각도처럼 단위가 다른 값) */
+export function annotationText(label: string, position: Point): Entity {
+	return textEntity(label, position, {
+		fontSize: getDimTextHeight() / worldFactor(),
+		textAlign: 'center',
+	});
+}
+
+/** DIMBASELINE·DIMCONTINUE가 이어 그릴 직전 치수 */
+let lastDimension: MeasurementEntity | null = null;
+
+export const rememberDimension = (dimension: MeasurementEntity): void => {
+	lastDimension = dimension;
+};
+
+export const getLastDimension = (): MeasurementEntity | null => lastDimension;
@@ -0,0 +1,256 @@
+/** 반지름·지름·각도·호길이·세로좌표 치수와 중심 표식 (조사표 5절) */
+import { Arc, Circle, Point } from '@flatten-js/core';
+import { toast } from 'react-toastify';
+import { getDimDecimals } from '../../commands/dim-settings';
+import type { Entity } from '../../entities/Entity';
+import { MeasurementEntity } from '../../entities/MeasurementEntity';
+import { polylineLength, sampleEntityPoints } from '../../helpers/geometry/sample-entity';
+import { addEntities, getEntities, setEntities, setSelectedEntityIds } from '../../state';
+import { Tool } from '../../tools';
+import { arcEntity, lineEntity } from '../factories/entity-factory';
+import { createSequenceTool } from '../factories/sequence-tool';
+import { annotationText, arrowHead, dimensionText } from './annotation.helpers';
+
+interface CircularShape {
+	center: Point;
+	radius: number;
+}
+
+/** 원·호에서 중심과 반지름을 꺼낸다 */
+function circularOf(entity: Entity): CircularShape | null {
+	const shape = entity.getShape();
+	if (shape instanceof Circle) return { center: shape.center, radius: Number(shape.r) };
+	if (shape instanceof Arc) return { center: shape.center, radius: Number(shape.r) };
+	return null;
+}
+
+function radialDimension(entity: Entity, textPoint: Point, diameter: boolean): Entity[] | null {
+	const circular = circularOf(entity);
+	if (!circular) return null;
+
+	const angle = Math.atan2(textPoint.y - circular.center.y, textPoint.x - circular.center.x);
+	const edge = new Point(
+		circular.center.x + circular.radius * Math.cos(angle),
+		circular.center.y + circular.radius * Math.sin(angle)
+	);
+	const start = diameter
+		? new Point(
+				circular.center.x - circular.radius * Math.cos(angle),
+				circular.center.y - circular.radius * Math.sin(angle)
+			)
+		: circular.center;
+
+	return [
+		lineEntity(start, textPoint),
+		arrowHead(edge, circular.center),
+		dimensionText(
+			diameter ? circular.radius * 2 : circular.radius,
+			textPoint,
+			diameter ? 'Ø' : 'R'
+		),
+	];
+}
+
+export const dimRadiusToolStateMachine = createSequenceTool({
+	tool: Tool.DIMRADIUS,
+	steps: [
+		{ kind: 'entity', instructions: '반지름을 기입할 원 또는 호를 선택하십시오.' },
+		{ kind: 'point', instructions: '치수 문자 위치를 지정하십시오.' },
+	],
+	commit: (input) => {
+		const parts = radialDimension(input.entity(0), input.point(1), false);
+		if (!parts) {
+			toast.warn('원 또는 호를 선택하십시오.');
+			return;
+		}
+		addEntities(parts, true);
+	},
+});
+
+export const dimDiameterToolStateMachine = createSequenceTool({
+	tool: Tool.DIMDIAMETER,
+	steps: [
+		{ kind: 'entity', instructions: '지름을 기입할 원 또는 호를 선택하십시오.' },
+		{ kind: 'point', instructions: '치수 문자 위치를 지정하십시오.' },
+	],
+	commit: (input) => {
+		const parts = radialDimension(input.entity(0), input.point(1), true);
+		if (!parts) {
+			toast.warn('원 또는 호를 선택하십시오.');
+			return;
+		}
+		addEntities(parts, true);
+	},
+});
+
+export const dimAngularToolStateMachine = createSequenceTool({
+	tool: Tool.DIMANGULAR,
+	steps: [
+		{ kind: 'point', instructions: '각의 꼭짓점을 지정하십시오.' },
+		{ kind: 'point', instructions: '첫 번째 변 위의 점을 지정하십시오.' },
+		{ kind: 'point', instructions: '두 번째 변 위의 점을 지정하십시오.' },
+	],
+	commit: (input) => {
+		const [vertex, first, second] = input.points();
+		const radius = Math.min(vertex.distanceTo(first)[0], vertex.distanceTo(second)[0]) * 0.6;
+		if (radius <= 0) return;
+
+		const startAngle = Math.atan2(first.y - vertex.y, first.x - vertex.x);
+		const endAngle = Math.atan2(second.y - vertex.y, second.x - vertex.x);
+		const sweep = ((endAngle - startAngle + 2 * Math.PI) % (2 * Math.PI));
+		const midAngle = startAngle + sweep / 2;
+		const degrees = (sweep * 180) / Math.PI;
+
+		addEntities(
+			[
+				lineEntity(vertex, first),
+				lineEntity(vertex, second),
+				arcEntity({
+					center: vertex,
+					radius,
+					startAngle,
+					endAngle,
+					counterClockwise: true,
+				}),
+				annotationText(
+					`${degrees.toFixed(getDimDecimals())}°`,
+					new Point(
+						vertex.x + radius * 1.25 * Math.cos(midAngle),
+						vertex.y + radius * 1.25 * Math.sin(midAngle)
+					)
+				),
+			],
+			true
+		);
+	},
+});
+
+export const dimArcToolStateMachine = createSequenceTool({
+	tool: Tool.DIMARC,
+	steps: [
+		{ kind: 'entity', instructions: '호 길이를 기입할 호를 선택하십시오.' },
+		{ kind: 'point', instructions: '치수 문자 위치를 지정하십시오.' },
+	],
+	commit: (input) => {
+		const entity = input.entity(0);
+		const circular = circularOf(entity);
+		if (!circular) {
+			toast.warn('호를 선택하십시오.');
+			return;
+		}
+		const length = polylineLength(sampleEntityPoints(entity));
+		addEntities([dimensionText(length, input.point(1), '⌒ ')], true);
+	},
+});
+
+export const dimOrdinateToolStateMachine = createSequenceTool({
+	tool: Tool.DIMORDINATE,
+	steps: [
+		{ kind: 'point', instructions: '좌표를 기입할 피처 위치를 지정하십시오.' },
+		{ kind: 'point', instructions: '지시선 끝점을 지정하십시오.' },
+	],
+	commit: (input) => {
+		const [feature, leaderEnd] = input.points();
+		// 지시선이 세로로 길면 X좌표를, 가로로 길면 Y좌표를 기입한다 (AutoCAD와 같다)
+		const vertical = Math.abs(leaderEnd.y - feature.y) >= Math.abs(leaderEnd.x - feature.x);
+		const value = vertical ? feature.x : feature.y;
+		addEntities(
+			[
+				lineEntity(feature, leaderEnd),
+				annotationText(
+					`${vertical ? 'X' : 'Y'} ${value.toFixed(getDimDecimals())}`,
+					new Point(leaderEnd.x, leaderEnd.y)
+				),
+			],
+			true
+		);
+	},
+});
+
+export const centerMarkToolStateMachine = createSequenceTool({
+	tool: Tool.CENTERMARK,
+	steps: [{ kind: 'entity', instructions: '중심 표식을 넣을 원 또는 호를 선택하십시오.' }],
+	commit: (input) => {
+		const circular = circularOf(input.entity(0));
+		if (!circular) {
+			toast.warn('원 또는 호를 선택하십시오.');
+			return;
+		}
+		const size = circular.radius * 0.15;
+		addEntities(
+			[
+				lineEntity(
+					new Point(circular.center.x - size, circular.center.y),
+					new Point(circular.center.x + size, circular.center.y)
+				),
+				lineEntity(
+					new Point(circular.center.x, circular.center.y - size),
+					new Point(circular.center.x, circular.center.y + size)
+				),
+			],
+			true
+		);
+	},
+});
+
+export const centerLineToolStateMachine = createSequenceTool({
+	tool: Tool.CENTERLINE,
+	helpers: false,
+	steps: [
+		{ kind: 'entity', instructions: '첫 번째 선을 선택하십시오.' },
+		{ kind: 'entity', instructions: '두 번째 선을 선택하십시오.' },
+	],
+	commit: (input) => {
+		const first = sampleEntityPoints(input.entity(0));
+		const second = sampleEntityPoints(input.entity(1));
+		if (first.length < 2 || second.length < 2) {
+			toast.warn('두 선을 선택하십시오.');
+			return;
+		}
+		const middle = (a: Point, b: Point) => new Point((a.x + b.x) / 2, (a.y + b.y) / 2);
+		const line = lineEntity(
+			middle(first[0], second[0]),
+			middle(first[first.length - 1], second[second.length - 1])
+		);
+		line.lineDash = [12, 4, 2, 4];
+		addEntities([line], true);
+	},
+});
+
+/** DIMSPACE — 선택한 치수들의 치수선 간격을 고르게 맞춘다 */
+export const dimSpaceToolStateMachine = createSequenceTool({
+	tool: Tool.DIMSPACE,
+	helpers: false,
+	steps: [
+		{ kind: 'selection', instructions: '간격을 맞출 치수를 선택한 뒤 ENTER.' },
+		{ kind: 'number', instructions: '치수선 간격을 입력하십시오 <10>.', defaultValue: 10 },
+	],
+	commit: (input) => {
+		const dimensions = input
+			.entities(0)
+			.filter((entity): entity is MeasurementEntity => entity instanceof MeasurementEntity);
+		if (dimensions.length < 2) {
+			toast.warn('치수를 두 개 이상 선택하십시오.');
+			return;
+		}
+		const spacing = input.number(1);
+		const base = dimensions[0];
+		const baseStart = base.getStartPoint();
+		const baseOffset = base.getOffsetPoint();
+		const direction = new Point(baseOffset.x - baseStart.x, baseOffset.y - baseStart.y);
+		const length = Math.hypot(direction.x, direction.y) || 1;
+
+		dimensions.forEach((dimension, index) => {
+			if (index === 0) return;
+			const start = dimension.getStartPoint();
+			dimension.setOffsetPoint(
+				new Point(
+					start.x + (direction.x / length) * (length + spacing * index),
+					start.y + (direction.y / length) * (length + spacing * index)
+				)
+			);
+		});
+		setEntities([...getEntities()], true);
+		setSelectedEntityIds([]);
+	},
+});
@@ -0,0 +1,163 @@
+/** 선형 치수 계열 — 선형·정렬·기준선·연속·빠른 치수·자동 치수 (조사표 5절) */
+import { Circle, Point } from '@flatten-js/core';
+import { toast } from 'react-toastify';
+import { EntityName } from '../../entities/Entity';
+import { MeasurementEntity } from '../../entities/MeasurementEntity';
+import { sampleEntityPoints } from '../../helpers/geometry/sample-entity';
+import { addEntities, getActiveLayerId, setSelectedEntityIds } from '../../state';
+import { Tool } from '../../tools';
+import { styled } from '../factories/entity-factory';
+import { createSequenceTool } from '../factories/sequence-tool';
+import { getLastDimension, rememberDimension } from './annotation.helpers';
+
+/** 치수 객체 하나 만들기 — 현재 선 특성을 입히고 직전 치수로 기억한다 */
+function makeDimension(start: Point, end: Point, offset: Point): MeasurementEntity {
+	const dimension = styled(new MeasurementEntity(getActiveLayerId(), start, end, offset));
+	rememberDimension(dimension);
+	return dimension;
+}
+
+/**
+ * 선형 치수 — 치수선을 놓은 방향으로 수평/수직을 고른다.
+ * 위·아래에 놓으면 가로 거리, 좌·우에 놓으면 세로 거리를 잰다 (AutoCAD와 같다).
+ */
+function projectForLinear(start: Point, end: Point, offset: Point): [Point, Point] {
+	const horizontalSpan = Math.abs(end.x - start.x);
+	const verticalSpan = Math.abs(end.y - start.y);
+	const offsetIsVertical =
+		Math.abs(offset.y - (start.y + end.y) / 2) >= Math.abs(offset.x - (start.x + end.x) / 2);
+	if (offsetIsVertical || horizontalSpan >= verticalSpan) {
+		return [start, new Point(end.x, start.y)];
+	}
+	return [start, new Point(start.x, end.y)];
+}
+
+export const dimLinearToolStateMachine = createSequenceTool({
+	tool: Tool.DIMLINEAR,
+	steps: [
+		{ kind: 'point', instructions: '첫 번째 치수보조선 원점을 지정하십시오.' },
+		{ kind: 'point', instructions: '두 번째 치수보조선 원점을 지정하십시오.' },
+		{ kind: 'point', instructions: '치수선 위치를 지정하십시오.' },
+	],
+	preview: (input) => {
+		const points = input.points();
+		if (points.length !== 2) return [];
+		const [start, end] = projectForLinear(points[0], points[1], input.cursor);
+		return [new MeasurementEntity(getActiveLayerId(), start, end, input.cursor)];
+	},
+	commit: (input) => {
+		const [first, second, offset] = input.points();
+		const [start, end] = projectForLinear(first, second, offset);
+		addEntities([makeDimension(start, end, offset)], true);
+	},
+});
+
+export const dimAlignedToolStateMachine = createSequenceTool({
+	tool: Tool.DIMALIGNED,
+	steps: [
+		{ kind: 'point', instructions: '첫 번째 치수보조선 원점을 지정하십시오.' },
+		{ kind: 'point', instructions: '두 번째 치수보조선 원점을 지정하십시오.' },
+		{ kind: 'point', instructions: '치수선 위치를 지정하십시오.' },
+	],
+	preview: (input) => {
+		const points = input.points();
+		if (points.length !== 2) return [];
+		return [new MeasurementEntity(getActiveLayerId(), points[0], points[1], input.cursor)];
+	},
+	commit: (input) => {
+		const [start, end, offset] = input.points();
+		addEntities([makeDimension(start, end, offset)], true);
+	},
+});
+
+export const dimBaselineToolStateMachine = createSequenceTool({
+	tool: Tool.DIMBASELINE,
+	steps: [{ kind: 'point', instructions: '다음 치수보조선 원점을 지정하십시오.' }],
+	commit: (input) => {
+		const previous = getLastDimension();
+		if (!previous) {
+			toast.warn('먼저 치수를 하나 작성하십시오.');
+			return;
+		}
+		const start = previous.getStartPoint();
+		const offset = previous.getOffsetPoint();
+		// 기준선 치수는 같은 시작점에서 재고, 치수선을 한 칸 더 띄운다
+		const spacing = offset.distanceTo(start)[0] * 0.35 || 10;
+		const direction = new Point(offset.x - start.x, offset.y - start.y);
+		const length = Math.hypot(direction.x, direction.y) || 1;
+		const nextOffset = new Point(
+			offset.x + (direction.x / length) * spacing,
+			offset.y + (direction.y / length) * spacing
+		);
+		addEntities([makeDimension(start, input.point(0), nextOffset)], true);
+	},
+});
+
+export const dimContinueToolStateMachine = createSequenceTool({
+	tool: Tool.DIMCONTINUE,
+	steps: [{ kind: 'point', instructions: '다음 치수보조선 원점을 지정하십시오.' }],
+	commit: (input) => {
+		const previous = getLastDimension();
+		if (!previous) {
+			toast.warn('먼저 치수를 하나 작성하십시오.');
+			return;
+		}
+		addEntities(
+			[makeDimension(previous.getEndPoint(), input.point(0), previous.getOffsetPoint())],
+			true
+		);
+	},
+});
+
+export const qDimToolStateMachine = createSequenceTool({
+	tool: Tool.QDIM,
+	helpers: false,
+	steps: [
+		{ kind: 'selection', instructions: '치수를 넣을 객체를 선택한 뒤 ENTER.' },
+		{ kind: 'point', instructions: '치수선 위치를 지정하십시오.' },
+	],
+	commit: (input) => {
+		const offset = input.point(1);
+		const dimensions = input
+			.entities(0)
+			.map((entity) => {
+				const points = sampleEntityPoints(entity);
+				if (points.length < 2) return null;
+				return makeDimension(points[0], points[points.length - 1], offset);
+			})
+			.filter((dimension): dimension is MeasurementEntity => !!dimension);
+		if (!dimensions.length) {
+			toast.warn('치수를 넣을 수 있는 객체가 없습니다.');
+			return;
+		}
+		addEntities(dimensions, true);
+		setSelectedEntityIds([]);
+	},
+});
+
+/** DIM — 선택한 객체 종류에 맞는 치수를 자동으로 고른다 */
+export const dimAutoToolStateMachine = createSequenceTool({
+	tool: Tool.DIM,
+	helpers: false,
+	steps: [
+		{ kind: 'entity', instructions: '치수를 넣을 객체를 선택하십시오.' },
+		{ kind: 'point', instructions: '치수선 위치를 지정하십시오.' },
+	],
+	commit: (input) => {
+		const entity = input.entity(0);
+		const offset = input.point(1);
+		const shape = entity.getShape();
+
+		if (shape instanceof Circle || entity.getType() === EntityName.Arc) {
+			// 원·호는 반지름 치수 명령이 더 알맞다
+			toast.info('원·호에는 DIMRADIUS 또는 DIMDIAMETER를 사용하십시오.');
+			return;
+		}
+		const points = sampleEntityPoints(entity);
+		if (points.length < 2) {
+			toast.warn('치수를 넣을 수 없는 객체입니다.');
+			return;
+		}
+		addEntities([makeDimension(points[0], points[points.length - 1], offset)], true);
+	},
+});
@@ -0,0 +1,209 @@
+/** 지시선·표·구름형·스타일 설정 (조사표 5절 지시선·표·표식·주석 축척) */
+import { Point } from '@flatten-js/core';
+import { toast } from 'react-toastify';
+import {
+	getAnnotationScale,
+	getDimTextHeight,
+	getTableColumnWidth,
+	getTableRowHeight,
+	setAnnotationScale,
+	setDimStyle,
+	setTableStyle,
+} from '../../commands/dim-settings';
+import type { Entity } from '../../entities/Entity';
+import { EntityName } from '../../entities/Entity';
+import type { TextEntity } from '../../entities/TextEntity';
+import { revisionCloudPoints } from '../../helpers/geometry/shape-points';
+import { addEntities, getEntities, setEntities, setSelectedEntityIds } from '../../state';
+import { Tool } from '../../tools';
+import { lineEntity, polyLineEntity } from '../factories/entity-factory';
+import { createSequenceTool } from '../factories/sequence-tool';
+import { annotationText, arrowHead, worldFactor } from './annotation.helpers';
+
+export const mleaderToolStateMachine = createSequenceTool({
+	tool: Tool.MLEADER,
+	steps: [
+		{ kind: 'point', instructions: '지시선 화살표 위치를 지정하십시오.' },
+		{ kind: 'point', instructions: '지시선 꺾임점을 지정하십시오.' },
+		{ kind: 'text', instructions: '지시선 문자를 입력하십시오.' },
+	],
+	preview: (input) => {
+		const points = input.points();
+		if (points.length !== 1) return [];
+		return [lineEntity(points[0], input.cursor), arrowHead(points[0], input.cursor)];
+	},
+	commit: (input) => {
+		const [tip, knee] = input.points();
+		const textHeight = getDimTextHeight() / worldFactor();
+		// 꺾임점에서 문자 쪽으로 짧은 가로선을 하나 더 뽑는다 (AutoCAD 지시선 모양)
+		const landingLength = textHeight * 2;
+		const toRight = knee.x >= tip.x;
+		const landingEnd = new Point(knee.x + (toRight ? landingLength : -landingLength), knee.y);
+		const label = annotationText(input.text(2), new Point(landingEnd.x, landingEnd.y + textHeight * 0.4));
+		const groupId = crypto.randomUUID();
+		const parts: Entity[] = [
+			lineEntity(tip, knee),
+			lineEntity(knee, landingEnd),
+			arrowHead(tip, knee),
+			label,
+		];
+		for (const part of parts) part.groupId = groupId;
+		addEntities(parts, true);
+	},
+});
+
+export const mleaderStyleToolStateMachine = createSequenceTool({
+	tool: Tool.MLEADERSTYLE,
+	helpers: false,
+	steps: [
+		{ kind: 'number', instructions: '지시선 문자 높이를 입력하십시오 <16>.', defaultValue: 16 },
+		{ kind: 'number', instructions: '화살표 크기를 입력하십시오 <20>.', defaultValue: 20 },
+	],
+	commit: (input) => {
+		setDimStyle(input.number(0), input.number(1), -1);
+		toast.success(`지시선 스타일: 문자 ${input.number(0)} · 화살표 ${input.number(1)}`);
+	},
+});
+
+/** 지시선 정렬 — 선택한 지시선 문자의 X 위치를 첫 문자에 맞춘다 */
+export const mleaderAlignToolStateMachine = createSequenceTool({
+	tool: Tool.MLEADERALIGN,
+	helpers: false,
+	steps: [{ kind: 'selection', instructions: '정렬할 지시선 문자를 선택한 뒤 ENTER.' }],
+	commit: (input) => {
+		const texts = input
+			.entities(0)
+			.filter((entity) => entity.getType() === EntityName.Text) as TextEntity[];
+		if (texts.length < 2) {
+			toast.warn('지시선 문자를 두 개 이상 선택하십시오.');
+			return;
+		}
+		const targetX = texts[0].getBoundingBox().xmin;
+		for (const text of texts.slice(1)) {
+			text.move(targetX - text.getBoundingBox().xmin, 0);
+		}
+		setEntities([...getEntities()], true);
+		setSelectedEntityIds([]);
+		toast.success(`${texts.length}개 지시선 문자를 정렬했습니다.`);
+	},
+});
+
+export const dimStyleToolStateMachine = createSequenceTool({
+	tool: Tool.DIMSTYLE,
+	helpers: false,
+	steps: [
+		{ kind: 'number', instructions: '치수 문자 높이를 입력하십시오 <16>.', defaultValue: 16 },
+		{ kind: 'number', instructions: '화살표 크기를 입력하십시오 <20>.', defaultValue: 20 },
+		{ kind: 'number', instructions: '소수 자릿수를 입력하십시오 <2>.', defaultValue: 2 },
+	],
+	commit: (input) => {
+		setDimStyle(input.number(0), input.number(1), input.number(2));
+		setEntities([...getEntities()], false);
+		toast.success('치수 스타일을 바꿨습니다.');
+	},
+});
+
+/** 치수 업데이트 — 스타일을 바꾼 뒤 화면을 다시 그린다 */
+export function updateDimensions(): string {
+	setEntities([...getEntities()], false);
+	toast.success('치수를 현재 스타일로 갱신했습니다.');
+	return '치수 업데이트';
+}
+
+export const annotationScaleToolStateMachine = createSequenceTool({
+	tool: Tool.ANNOSCALE,
+	helpers: false,
+	steps: [{ kind: 'number', instructions: '주석 축척 배율을 입력하십시오 <1>.', defaultValue: 1 }],
+	commit: (input) => {
+		setAnnotationScale(input.number(0));
+		setEntities([...getEntities()], false);
+		toast.success(`주석 축척 ${getAnnotationScale()}배`);
+	},
+});
+
+export const tableStyleToolStateMachine = createSequenceTool({
+	tool: Tool.TABLESTYLE,
+	helpers: false,
+	steps: [
+		{ kind: 'number', instructions: '열 너비를 입력하십시오 <40>.', defaultValue: 40 },
+		{ kind: 'number', instructions: '행 높이를 입력하십시오 <10>.', defaultValue: 10 },
+	],
+	commit: (input) => {
+		setTableStyle(input.number(0), input.number(1));
+		toast.success(`표 스타일: 열 ${input.number(0)} · 행 ${input.number(1)}`);
+	},
+});
+
+export const tableToolStateMachine = createSequenceTool({
+	tool: Tool.TABLE,
+	steps: [
+		{ kind: 'number', instructions: '열 수를 입력하십시오 <3>.', defaultValue: 3 },
+		{ kind: 'number', instructions: '행 수를 입력하십시오 <3>.', defaultValue: 3 },
+		{ kind: 'point', instructions: '표의 좌측 상단 삽입점을 지정하십시오.' },
+	],
+	commit: (input) => {
+		const columns = Math.max(1, Math.round(input.number(0)));
+		const rows = Math.max(1, Math.round(input.number(1)));
+		const origin = input.point(2);
+		const width = getTableColumnWidth();
+		const height = getTableRowHeight();
+		const groupId = crypto.randomUUID();
+		const parts: Entity[] = [];
+
+		for (let column = 0; column <= columns; column++) {
+			parts.push(
+				lineEntity(
+					new Point(origin.x + column * width, origin.y),
+					new Point(origin.x + column * width, origin.y - rows * height)
+				)
+			);
+		}
+		for (let row = 0; row <= rows; row++) {
+			parts.push(
+				lineEntity(
+					new Point(origin.x, origin.y - row * height),
+					new Point(origin.x + columns * width, origin.y - row * height)
+				)
+			);
+		}
+		for (const part of parts) part.groupId = groupId;
+		addEntities(parts, true);
+		toast.info('표를 만들었습니다. 칸 내용은 문자(TEXT) 명령으로 채우십시오.');
+	},
+});
+
+export const revCloudToolStateMachine = createSequenceTool({
+	tool: Tool.REVCLOUD,
+	steps: [
+		{ kind: 'point', instructions: '구름형 경로의 첫 점을 지정하십시오.' },
+		{ kind: 'point', instructions: '다음 점을 지정하십시오. ENTER로 닫습니다.' },
+	],
+	repeatLastStep: true,
+	preview: (input) => {
+		const preview = polyLineEntity([...input.points(), input.cursor]);
+		return preview ? [preview] : [];
+	},
+	commit: (input) => {
+		const points = input.points();
+		if (points.length < 2) return;
+		const closed = [...points, points[0].clone()];
+		const box = closed.reduce(
+			(size, point) => ({
+				minX: Math.min(size.minX, point.x),
+				minY: Math.min(size.minY, point.y),
+				maxX: Math.max(size.maxX, point.x),
+				maxY: Math.max(size.maxY, point.y),
+			}),
+			{
+				minX: Number.POSITIVE_INFINITY,
+				minY: Number.POSITIVE_INFINITY,
+				maxX: Number.NEGATIVE_INFINITY,
+				maxY: Number.NEGATIVE_INFINITY,
+			}
+		);
+		// 스캘럽 크기는 구름 크기에 비례시켜 어떤 축척에서도 비슷하게 보이게 한다
+		const arcRadius = Math.max(Math.hypot(box.maxX - box.minX, box.maxY - box.minY) / 40, 1e-6);
+		const cloud = polyLineEntity(revisionCloudPoints(closed, arcRadius));
+		if (cloud) addEntities([cloud], true);
+	},
+});
@@ -0,0 +1,103 @@
+/** 문자 명령 — 여러 줄 문자·단일 행 문자·편집·찾기 (조사표 5절 문자 패널) */
+import { Point } from '@flatten-js/core';
+import { toast } from 'react-toastify';
+import { getAnnotationScale } from '../../commands/dim-settings';
+import { EntityName } from '../../entities/Entity';
+import type { Entity } from '../../entities/Entity';
+import type { TextEntity } from '../../entities/TextEntity';
+import { addEntities, getActiveTextStyle, getEntities, setEntities } from '../../state';
+import { Tool } from '../../tools';
+import { textEntity } from '../factories/entity-factory';
+import { createSequenceTool } from '../factories/sequence-tool';
+
+/** AutoCAD 여러 줄 문자의 줄바꿈 표기(\P)와 \n을 모두 받는다 */
+const splitLines = (text: string): string[] =>
+	text
+		.replace(/\\P/gi, '\n')
+		.split('\n')
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0);
+
+function buildTextLines(lines: string[], basePoint: Point): Entity[] {
+	const lineHeight = getActiveTextStyle().fontSize * getAnnotationScale() * 1.35;
+	const groupId = lines.length > 1 ? crypto.randomUUID() : undefined;
+	return lines.map((line, index) => {
+		const entity = textEntity(line, new Point(basePoint.x, basePoint.y - lineHeight * index), {
+			textAlign: 'left',
+			fontSize: getActiveTextStyle().fontSize * getAnnotationScale(),
+		});
+		entity.groupId = groupId;
+		return entity;
+	});
+}
+
+export const textToolStateMachine = createSequenceTool({
+	tool: Tool.TEXT,
+	steps: [
+		{ kind: 'point', instructions: '문자의 시작점을 지정하십시오.' },
+		{ kind: 'text', instructions: '문자를 입력하십시오.' },
+	],
+	commit: (input) => {
+		const lines = splitLines(input.text(1));
+		if (!lines.length) return;
+		addEntities(buildTextLines(lines.slice(0, 1), input.point(0)), true);
+	},
+});
+
+export const mtextToolStateMachine = createSequenceTool({
+	tool: Tool.MTEXT,
+	steps: [
+		{ kind: 'point', instructions: '여러 줄 문자의 첫 코너를 지정하십시오.' },
+		{ kind: 'text', instructions: '문자를 입력하십시오 (줄바꿈은 \\P).' },
+	],
+	commit: (input) => {
+		const lines = splitLines(input.text(1));
+		if (!lines.length) return;
+		addEntities(buildTextLines(lines, input.point(0)), true);
+	},
+});
+
+export const textEditToolStateMachine = createSequenceTool({
+	tool: Tool.TEXTEDIT,
+	helpers: false,
+	steps: [
+		{ kind: 'entity', instructions: '편집할 문자를 선택하십시오.' },
+		{ kind: 'text', instructions: '새 문자를 입력하십시오.' },
+	],
+	commit: (input) => {
+		const entity = input.entity(0);
+		if (entity.getType() !== EntityName.Text) {
+			toast.warn('문자 객체를 선택하십시오.');
+			return;
+		}
+		(entity as TextEntity).setLabel(input.text(1));
+		setEntities([...getEntities()], true);
+	},
+});
+
+export const findToolStateMachine = createSequenceTool({
+	tool: Tool.FIND,
+	helpers: false,
+	steps: [
+		{ kind: 'text', instructions: '찾을 문자열을 입력하십시오.' },
+		{ kind: 'text', instructions: '바꿀 문자열을 입력하십시오 (그대로 두려면 ENTER).', defaultValue: '' },
+	],
+	commit: (input) => {
+		const needle = input.text(0);
+		const replacement = input.text(1);
+		let found = 0;
+		let replaced = 0;
+		for (const entity of getEntities()) {
+			if (entity.getType() !== EntityName.Text) continue;
+			const text = entity as TextEntity;
+			if (!text.getLabel().includes(needle)) continue;
+			found += 1;
+			if (replacement) {
+				text.setLabel(text.getLabel().split(needle).join(replacement));
+				replaced += 1;
+			}
+		}
+		if (replaced) setEntities([...getEntities()], true);
+		toast.info(replaced ? `${replaced}개 문자를 바꿨습니다.` : `${found}개 문자를 찾았습니다.`);
+	},
+});