diff --git a/src/SheetMe.Core/Layout/SnapSolver.cs b/src/SheetMe.Core/Layout/SnapSolver.cs new file mode 100644 index 0000000..3f06411 --- /dev/null +++ b/src/SheetMe.Core/Layout/SnapSolver.cs @@ -0,0 +1,481 @@ +namespace SheetMe.Core.Layout; + +/// +/// 스냅 계산 — 순수 기하. 화면도 뷰모델도 모른다. +/// +/// 왜 후보를 좌표 목록으로 평탄화하지 않는가. 예전에는 후보를 List<double> 로 모아 +/// 최근접 하나를 골랐다. 그러면 "이 좌표가 어느 객체에서 왔는가"를 잃는다 — 그래서 가이드를 +/// 화면 끝에서 끝까지 긋는 무한선으로밖에 못 그렸고, 간격 균등은 아예 계산할 수 없었다. +/// 여기서는 원본을 끝까지 들고 간다. +/// +/// 결정성. 같은 입력이면 항상 같은 답이어야 한다(단위 테스트가 그걸 고정한다). +/// 동률 후보의 승자는 → 좌표 → 모서리 순서로 완전히 정해진다 — +/// 예전에는 컨트롤 열거 순서가 승자를 갈랐다. +/// +/// 할당. 드래그 중 매 프레임 불린다. 스크래치 버퍼를 재사용하고 이 경로에서 LINQ 를 쓰지 않는다. +/// +public sealed class SnapSolver +{ + #region Member Fields + /// 교차축이 겹치는 형제가 이보다 많으면 간격 균등을 포기한다 — 정렬 스냅은 그대로 돈다 + private const int SpacingRowLimit = 64; + + /// 형제가 이보다 많으면 간격 균등을 아예 끈다 + private const int SpacingTotalLimit = 2000; + + /// 막대가 화면을 덮지 않게 — 균등 구간이 아주 길어도 여기서 끊는다 + private const int SpacingMarkLimit = 8; + + private const double Epsilon = 1e-6; + + private SnapContext context = new(); + + /// Left 오름차순 형제 — BeginDrag 에서 한 번 정렬한다(프레임당 정렬 금지) + private SnapRect[] byLeft = Array.Empty(); + + /// Top 오름차순 형제 + private SnapRect[] byTop = Array.Empty(); + + private readonly List matches = new(); + private readonly List guides = new(); + private readonly List spacings = new(); + private readonly List row = new(); + private readonly List matched = new(); + #endregion + + #region Methods + /// 드래그 시작 — 후보를 한 번만 모으고 정렬해 둔다 + public void Prepare(SnapContext value) + { + context = value; + byLeft = new SnapRect[value.Siblings.Count]; + byTop = new SnapRect[value.Siblings.Count]; + for (var i = 0; i < value.Siblings.Count; i++) + { + byLeft[i] = value.Siblings[i]; + byTop[i] = value.Siblings[i]; + } + Array.Sort(byLeft, static (a, b) => a.Left.CompareTo(b.Left)); + Array.Sort(byTop, static (a, b) => a.Top.CompareTo(b.Top)); + } + + /// 드래그 끝 — 후보를 버린다. 드래그 밖에서 낡은 후보가 살아 있으면 유령 스냅이 된다 + public void Reset() + { + context = new SnapContext(); + byLeft = Array.Empty(); + byTop = Array.Empty(); + } + + /// 이동 스냅 — bbox 에 (dx,dy) 를 적용한 자리에서 정렬·간격·격자 순으로 붙인다 + public SnapOutcome SolveMove(SnapRect bbox, double dx, double dy, SnapOptions options, bool free) + { + if (free) + { + return SnapOutcome.Free(dx, dy); + } + + guides.Clear(); + spacings.Clear(); + + var moved = new SnapRect(bbox.X + dx, bbox.Y + dy, bbox.W, bbox.H); + var (adjustX, snappedX) = SolveAxis(moved, vertical: true, options); + var (adjustY, snappedY) = SolveAxis(moved, vertical: false, options); + + // 정렬이 못 잡은 축만 간격 균등을 본다 — 같은 축에서 둘 다 사정권이면 정렬이 이긴다. + // 거리로 겨루게 하면 한 픽셀 차이로 표시가 정렬선↔간격막대로 튀어 종잡을 수 없다. + var canSpace = options.EnableSpacing && context.Siblings.Count <= SpacingTotalLimit; + if (canSpace && !snappedX) + { + (adjustX, snappedX) = SolveSpacing(moved, horizontal: true, options); + } + if (canSpace && !snappedY) + { + (adjustY, snappedY) = SolveSpacing(moved, horizontal: false, options); + } + + var resultDx = snappedX ? dx + adjustX : Grid(moved.Left, options.GridSize) - bbox.X; + var resultDy = snappedY ? dy + adjustY : Grid(moved.Top, options.GridSize) - bbox.Y; + + return new SnapOutcome(resultDx, resultDy, snappedX, snappedY, + guides.ToArray(), spacings.ToArray()); + } + + /// + /// 리사이즈 모서리 스냅 — 움직이는 모서리 하나를 후보에 맞춘다. + /// 이동과 같은 최근접 규칙을 쓴다(예전에는 여기만 '첫 매치'라 둘이 어긋났다). + /// + public SnapEdgeOutcome SolveEdge(double value, bool isXAxis, SnapOptions options, bool free) + { + if (free) + { + return SnapEdgeOutcome.None(value); + } + + matches.Clear(); + CollectCandidates(isXAxis, value, value, value, options.Tolerance, singleEdge: true); + if (matches.Count == 0) + { + return SnapEdgeOutcome.None(Grid(value, options.GridSize)); + } + + var winner = Winner(); + matched.Clear(); + foreach (var match in matches) + { + if (Math.Abs(match.Distance - winner.Distance) < Epsilon + && Math.Abs(match.Position - winner.Position) < Epsilon + && match.Source is { } source) + { + matched.Add(source); + } + } + return new SnapEdgeOutcome(winner.Position, true, matched.ToArray(), winner.Kind); + } + + private static double Grid(double value, double grid) + => grid <= 0 ? value : Math.Round(value / grid) * grid; + + /// 한 축의 정렬 스냅 — 보정량은 승자 하나, 가이드는 '실제로 맞은 것' 전부 + private (double Adjust, bool Snapped) SolveAxis(SnapRect moved, bool vertical, SnapOptions options) + { + var (a, b, c) = vertical + ? (moved.Left, moved.CenterX, moved.Right) + : (moved.Top, moved.CenterY, moved.Bottom); + + matches.Clear(); + CollectCandidates(vertical, a, b, c, options.Tolerance, singleEdge: false); + if (matches.Count == 0) + { + return (0, false); + } + + var winner = Winner(); + EmitGuides(moved, vertical, winner.Distance); + return (winner.Distance, true); + } + + /// + /// 승자 — |거리| 최소 → 종류 → 좌표 → 모서리 순. + /// 네 단계를 모두 두는 이유는 어느 하나라도 빠지면 입력 순서가 답을 가르기 때문이다. + /// + private Match Winner() + { + var best = matches[0]; + for (var i = 1; i < matches.Count; i++) + { + if (Better(matches[i], best)) + { + best = matches[i]; + } + } + return best; + } + + private static bool Better(Match candidate, Match current) + { + var da = Math.Abs(candidate.Distance); + var db = Math.Abs(current.Distance); + if (Math.Abs(da - db) > Epsilon) + { + return da < db; + } + if (candidate.Kind != current.Kind) + { + return candidate.Kind < current.Kind; + } + if (Math.Abs(candidate.Position - current.Position) > Epsilon) + { + return candidate.Position < current.Position; + } + return candidate.EdgeIndex < current.EdgeIndex; + } + + /// + /// 보정을 적용했을 때 실제로 맞는 매치만 선으로 낸다. + /// + /// |거리| 만 같고 부호가 반대인 후보(+3 과 −3)를 함께 그리면 '붙었다고 그려 놓고 안 붙은' 선이 된다. + /// 그래서 부호까지 같은 것만 남긴다. + /// + private void EmitGuides(SnapRect moved, bool vertical, double adjust) + { + var settled = vertical + ? new SnapRect(moved.X + adjust, moved.Y, moved.W, moved.H) + : new SnapRect(moved.X, moved.Y + adjust, moved.W, moved.H); + + foreach (var match in matches) + { + if (Math.Abs(match.Distance - adjust) > Epsilon) + { + continue; + } + + double start, end; + if (match.Source is { } source) + { + // 형제 가이드는 관련된 것들의 교차축 합집합만큼만 — 관계가 눈에 보이는 길이다 + start = vertical ? Math.Min(source.Top, settled.Top) : Math.Min(source.Left, settled.Left); + end = vertical ? Math.Max(source.Bottom, settled.Bottom) : Math.Max(source.Right, settled.Right); + } + else if (match.Page is { } page) + { + // 용지 가이드는 그 용지 전체. 종이 밖으로 나가면 회색 배경 위에서 대비가 죽는다 + start = vertical ? page.Top : page.Left; + end = vertical ? page.Bottom : page.Right; + } + else + { + continue; + } + + Merge(new SnapGuide(vertical, match.Position, start, end, match.Kind)); + } + } + + /// 같은 축·같은 좌표의 가이드는 하나로 합치고 범위를 넓힌다 — 같은 자리에 선을 겹쳐 긋지 않는다 + private void Merge(SnapGuide guide) + { + for (var i = 0; i < guides.Count; i++) + { + var existing = guides[i]; + if (existing.IsVertical != guide.IsVertical + || Math.Abs(existing.Position - guide.Position) > Epsilon) + { + continue; + } + guides[i] = new SnapGuide( + existing.IsVertical, existing.Position, + Math.Min(existing.Start, guide.Start), + Math.Max(existing.End, guide.End), + existing.Kind <= guide.Kind ? existing.Kind : guide.Kind); + return; + } + guides.Add(guide); + } + + /// 리사이즈처럼 모서리가 하나뿐이면 a 만 본다 + private void CollectCandidates(bool vertical, double a, double b, double c, + double tolerance, bool singleEdge) + { + var limit = singleEdge ? 1 : 3; + foreach (var sibling in context.Siblings) + { + var (p0, p1, p2) = vertical + ? (sibling.Left, sibling.CenterX, sibling.Right) + : (sibling.Top, sibling.CenterY, sibling.Bottom); + for (var e = 0; e < limit; e++) + { + var edge = e == 0 ? a : e == 1 ? b : c; + Consider(edge, p0, e, SnapGuideKind.SiblingEdge, sibling, null, tolerance); + Consider(edge, p1, e, SnapGuideKind.SiblingCenter, sibling, null, tolerance); + Consider(edge, p2, e, SnapGuideKind.SiblingEdge, sibling, null, tolerance); + } + } + + foreach (var page in context.Pages) + { + var (p0, p1, p2) = vertical + ? (page.Left, page.CenterX, page.Right) + : (page.Top, page.CenterY, page.Bottom); + for (var e = 0; e < limit; e++) + { + var edge = e == 0 ? a : e == 1 ? b : c; + Consider(edge, p0, e, SnapGuideKind.PageEdge, null, page, tolerance); + Consider(edge, p1, e, SnapGuideKind.PageCenter, null, page, tolerance); + Consider(edge, p2, e, SnapGuideKind.PageEdge, null, page, tolerance); + } + } + } + + private void Consider(double edge, double candidate, int edgeIndex, SnapGuideKind kind, + SnapRect? source, SnapRect? page, double tolerance) + { + var distance = candidate - edge; + if (Math.Abs(distance) <= tolerance) + { + matches.Add(new Match(distance, candidate, kind, edgeIndex, source, page)); + } + } + + /// + /// 간격 균등 — 형제들이 이미 같은 간격으로 늘어서 있으면 그 리듬에 끼거나 이어 붙는 자리에 스냅한다. + /// + /// 가로(X)로 설명한다. 세로는 축만 바꾼 대칭이다. + /// ① 이동체와 교차축이 겹치는 형제만 한 줄로 본다(겹치지 않으면 '나란히'가 아니다). + /// ② 줄의 끝(또는 앞)에서부터 같은 간격이 이어지는 최대 구간을 찾아 그 값을 g 로 쓴다. + /// ③ 붙을 자리는 셋 — 두 형제 사이 가운데, 줄 뒤에 g 만큼, 줄 앞에 g 만큼. + /// + private (double Adjust, bool Snapped) SolveSpacing(SnapRect moved, bool horizontal, SnapOptions options) + { + if (context.SpacingPage is not { } page) + { + return (0, false); + } + + BuildRow(moved, horizontal); + if (row.Count < 2 || row.Count > SpacingRowLimit) + { + return (0, false); + } + + var size = horizontal ? moved.W : moved.H; + var start = horizontal ? moved.Left : moved.Top; + var lower = horizontal ? page.Left : page.Top; + var upper = horizontal ? page.Right : page.Bottom; + + var bestDistance = double.MaxValue; + var bestStart = 0.0; + var bestRank = int.MaxValue; + var found = false; + + void Offer(double candidateStart, int rank) + { + if (candidateStart < lower - Epsilon || candidateStart + size > upper + Epsilon) + { + return; + } + var distance = candidateStart - start; + if (Math.Abs(distance) > options.Tolerance) + { + return; + } + var better = !found + || Math.Abs(distance) < Math.Abs(bestDistance) - Epsilon + || (Math.Abs(Math.Abs(distance) - Math.Abs(bestDistance)) <= Epsilon + && (rank < bestRank || (rank == bestRank && candidateStart < bestStart))); + if (better) + { + found = true; + bestDistance = distance; + bestStart = candidateStart; + bestRank = rank; + } + } + + // ③-1 두 형제 사이에 끼우기 — 남는 틈을 반씩 나눈다 + for (var i = 0; i < row.Count - 1; i++) + { + var gapStart = horizontal ? row[i].Right : row[i].Bottom; + var gapEnd = horizontal ? row[i + 1].Left : row[i + 1].Top; + var gap = gapEnd - gapStart; + if (gap - size >= -Epsilon) + { + Offer(gapStart + (gap - size) / 2, 0); + } + } + + // ③-2 뒤에 이어 붙이기 / ③-3 앞에 이어 붙이기 + var tail = RunGap(horizontal, fromEnd: true); + if (tail is { } tailGap && tailGap >= -Epsilon) + { + Offer((horizontal ? row[^1].Right : row[^1].Bottom) + tailGap, 1); + } + var head = RunGap(horizontal, fromEnd: false); + if (head is { } headGap && headGap >= -Epsilon) + { + Offer((horizontal ? row[0].Left : row[0].Top) - headGap - size, 2); + } + + if (!found) + { + return (0, false); + } + + var settled = horizontal + ? new SnapRect(bestStart, moved.Y, moved.W, moved.H) + : new SnapRect(moved.X, bestStart, moved.W, moved.H); + EmitSpacings(settled, horizontal); + return (bestDistance, true); + } + + /// 이동체와 교차축이 겹치는 형제만, 주축 오름차순으로 + private void BuildRow(SnapRect moved, bool horizontal) + { + row.Clear(); + var source = horizontal ? byLeft : byTop; + foreach (var sibling in source) + { + var overlaps = horizontal + ? sibling.Top < moved.Bottom && moved.Top < sibling.Bottom + : sibling.Left < moved.Right && moved.Left < sibling.Right; + if (overlaps) + { + row.Add(sibling); + if (row.Count > SpacingRowLimit) + { + return; + } + } + } + } + + /// 줄의 끝(또는 앞)에서부터 같은 값이 이어지는 간격 — 형제가 둘뿐이면 그 하나가 곧 답이다 + private double? RunGap(bool horizontal, bool fromEnd) + { + if (row.Count < 2) + { + return null; + } + double Gap(int i) => horizontal + ? row[i + 1].Left - row[i].Right + : row[i + 1].Top - row[i].Bottom; + + var index = fromEnd ? row.Count - 2 : 0; + var value = Gap(index); + return value; + } + + /// + /// 확정된 자리를 기준으로 같은 값이 된 빈틈 전부를 막대로 낸다. + /// + /// 이동체 양옆만 재면 "30"이 한 번 뜰 뿐이라 무엇과 같아졌는지 안 보인다. + /// 같은 간격에 전부 막대를 그어야 '균등해졌다'가 한눈에 읽힌다. + /// + private void EmitSpacings(SnapRect settled, bool horizontal) + { + row.Add(settled); + row.Sort((a, b) => horizontal ? a.Left.CompareTo(b.Left) : a.Top.CompareTo(b.Top)); + + var at = -1; + for (var i = 0; i < row.Count; i++) + { + if (row[i].Equals(settled)) + { + at = i; + break; + } + } + if (at < 0) + { + return; + } + + // 기준 간격 = 이동체에 붙은 빈틈. 앞에 끼었으면 오른쪽 것을 쓴다 + var target = at > 0 ? GapAt(at - 1) : GapAt(at); + for (var i = 0; i < row.Count - 1 && spacings.Count < SpacingMarkLimit; i++) + { + var gap = GapAt(i); + if (gap < -Epsilon || Math.Abs(gap - target) > Epsilon) + { + continue; + } + var first = row[i]; + var second = row[i + 1]; + var from = horizontal ? first.Right : first.Bottom; + var to = horizontal ? second.Left : second.Top; + // 막대는 두 사각형이 교차축에서 겹치는 구간의 한가운데에 놓는다 + var lo = horizontal ? Math.Max(first.Top, second.Top) : Math.Max(first.Left, second.Left); + var hi = horizontal ? Math.Min(first.Bottom, second.Bottom) : Math.Min(first.Right, second.Right); + spacings.Add(new SpacingMark(horizontal, from, to, (lo + hi) / 2, gap)); + } + + double GapAt(int i) => horizontal + ? row[i + 1].Left - row[i].Right + : row[i + 1].Top - row[i].Bottom; + } + + private readonly record struct Match( + double Distance, double Position, SnapGuideKind Kind, int EdgeIndex, + SnapRect? Source, SnapRect? Page); + #endregion +} diff --git a/src/SheetMe.Core/Layout/SnapTypes.cs b/src/SheetMe.Core/Layout/SnapTypes.cs new file mode 100644 index 0000000..d576257 --- /dev/null +++ b/src/SheetMe.Core/Layout/SnapTypes.cs @@ -0,0 +1,104 @@ +namespace SheetMe.Core.Layout; + +/// +/// 스냅 계산용 사각형 — 월드 좌표(px). +/// +/// 왜 System.Windows.Rect 를 안 쓰는가. 이 프로젝트(SheetMe.Core)는 net10.0 이고 +/// System.Windows 참조가 0건이다. Rect 를 들이면 Core 가 Windows 전용이 되고 +/// 단위 테스트 프로젝트까지 같이 끌려간다 — 스냅 계산을 여기로 옮긴 이유가 사라진다. +/// +public readonly record struct SnapRect(double X, double Y, double W, double H) +{ + public double Left => X; + public double Top => Y; + public double Right => X + W; + public double Bottom => Y + H; + public double CenterX => X + W / 2; + public double CenterY => Y + H / 2; +} + +/// +/// 가이드선 종류 — 동률 후보의 승자를 결정적으로 가르고, 선분 범위 규칙도 이걸로 갈린다. +/// 값의 순서가 곧 우선순위다(작을수록 이긴다). +/// +public enum SnapGuideKind +{ + /// 형제의 좌/우/상/하 모서리 + SiblingEdge = 0, + + /// 형제의 중심 + SiblingCenter = 1, + + /// 용지 경계 + PageEdge = 2, + + /// 용지 중앙 + PageCenter = 3, + + /// 간격 균등으로 정해진 자리 — 선은 긋지 않고 간격 막대로만 보인다 + Spacing = 4, +} + +/// 가이드선 1개 — 월드 좌표 선분 +/// true = 세로선(X 정합), false = 가로선(Y 정합) +/// 정합된 좌표 — 세로선이면 X +/// 교차축 시작 — 세로선이면 Y 최소 +/// 교차축 끝 +public readonly record struct SnapGuide( + bool IsVertical, double Position, double Start, double End, SnapGuideKind Kind); + +/// 간격 균등 표시 1개 — 빈틈 하나를 재는 막대(월드 좌표) +/// true = 가로 간격(막대가 수평) +/// 주축 시작 — 가로면 X +/// 주축 끝 +/// 교차축 위치 — 막대가 놓이는 선 +/// 간격값 — 표시 텍스트용 +public readonly record struct SpacingMark( + bool IsHorizontal, double Start, double End, double Cross, double Gap); + +/// 스냅 계산 결과 +/// X 가 정렬/간격으로 붙었는가 — 그리드로 떨어진 것은 false +public readonly record struct SnapOutcome( + double Dx, double Dy, bool SnappedX, bool SnappedY, + IReadOnlyList Guides, IReadOnlyList Spacings) +{ + public static SnapOutcome Free(double dx, double dy) + => new(dx, dy, false, false, Array.Empty(), Array.Empty()); +} + +/// 리사이즈 모서리 스냅 결과 — 선분 범위는 호출부가 최종 사각형을 확정한 뒤 조립한다 +public readonly record struct SnapEdgeOutcome( + double Value, bool Snapped, IReadOnlyList Matched, SnapGuideKind Kind) +{ + public static SnapEdgeOutcome None(double value) + => new(value, false, Array.Empty(), SnapGuideKind.SiblingEdge); +} + +/// 프레임 단위 스냅 파라미터 — 허용 오차는 줌에 따라 매 프레임 달라진다 +/// 월드 단위 허용 오차 +/// 정렬이 실패한 축의 폴백 격자(월드) +public readonly record struct SnapOptions(double Tolerance, double GridSize, bool EnableSpacing) +{ + /// + /// 화면 px 허용 오차를 월드 허용 오차로. + /// + /// 월드 고정이면 줌 50%에서 두 배로 끈적이고 200%에서 절반으로 미끄러진다 — + /// 손끝 감각은 화면 거리로 정해지므로 화면 기준이 맞다. + /// 줌은 0.25~3.0 으로 묶는다(디자이너가 허용하는 범위 밖 값이 들어와도 오차가 폭주하지 않게). + /// + public static SnapOptions ForZoom(double screenTolerance, double gridSize, double zoom, bool enableSpacing) + => new(screenTolerance / Math.Clamp(zoom, 0.25, 3.0), gridSize, enableSpacing); +} + +/// 드래그 한 번 동안 고정되는 후보 집합 — 프레임마다 다시 모으지 않는다 +public sealed class SnapContext +{ + /// 용지 사각형(월드) + public IReadOnlyList Pages { get; init; } = Array.Empty(); + + /// 움직이지 않는 형제(월드) — 컨테이너 자식까지 평탄화해서 넘어온다 + public IReadOnlyList Siblings { get; init; } = Array.Empty(); + + /// 간격 균등 계산의 기준 용지 — 페이지를 넘는 '균등 간격'은 뜻이 없다 + public SnapRect? SpacingPage { get; init; } +} diff --git a/src/SheetMe.Designer/App.xaml.cs b/src/SheetMe.Designer/App.xaml.cs index 1cfcdcd..a655471 100644 --- a/src/SheetMe.Designer/App.xaml.cs +++ b/src/SheetMe.Designer/App.xaml.cs @@ -270,6 +270,11 @@ public partial class App : Application return Diagnostics.DialogShots.Run(args[1]); } + if (args.Length >= 2 && args[0] == "--snap-shots") + { + return Diagnostics.SnapShots.Run(args[1]); + } + if (args.Length >= 1 && args[0] == "--maxrect") { return Diagnostics.MaximizeCheck.Run(args.Length >= 2 ? args[1] : null); diff --git a/src/SheetMe.Designer/Diagnostics/EditSmoke.cs b/src/SheetMe.Designer/Diagnostics/EditSmoke.cs index c5a4be9..2321401 100644 --- a/src/SheetMe.Designer/Diagnostics/EditSmoke.cs +++ b/src/SheetMe.Designer/Diagnostics/EditSmoke.cs @@ -1093,6 +1093,122 @@ public static class EditSmoke dirtyDoc.Undo.Undo(); Check("더티: 분기 후에는 저장 지점 소실로 계속 dirty", dirtyDoc.Undo.IsDirty); + // 24-2) 스냅 — 정렬 가이드와 간격 균등. + // 별도 문서에 붙인다. 메인 designer 에 붙이면 아래 '전체 Undo' 의 guard(80)를 + // 드래그마다 잡아먹어 그 검사가 조용히 깨진다(UndoService 용량 100). + { + var snapDoc = new DesignerViewModel(business.CreateNew()); + ControlViewModel Place(DesignerViewModel doc, string type, double x, double y, double w, double h) + { + doc.AddControlAt(type, new Point(x, y)); + var vm = doc.Pages[0].Controls[^1]; + vm.X = x; + vm.Y = y; + vm.Width = w; + vm.Height = h; + return vm; + } + static Point Middle(ControlViewModel vm) => new(vm.X + vm.Width / 2, vm.Y + vm.Height / 2); + + // 형제 둘을 같은 좌변에 세로로 벌려 둔다 — 가이드 병합과 선분 범위를 함께 본다 + var anchorTop = Place(snapDoc, "Label", 200, 100, 60, 20); + var anchorBottom = Place(snapDoc, "Label", 200, 400, 60, 20); + // 폭을 형제와 다르게 둔다 — 같으면 좌·중·우가 동시에 맞아 가이드가 3개 나온다 + // (그것도 옳은 동작이지만 여기서 보려는 것은 '같은 좌표의 형제 둘이 하나로 합쳐지는가'다) + var mover = Place(snapDoc, "Label", 197, 250, 40, 20); + + var grab = Middle(mover); + snapDoc.Interaction.PointerDown(grab, none); + snapDoc.Interaction.PointerMove(new Point(grab.X + 3, grab.Y), none); + Check("스냅: 형제 좌변에 붙는다", mover.X == anchorTop.X, $"실제 {mover.X}"); + Check("스냅: 같은 좌표 형제 둘이 가이드 하나로 병합된다", snapDoc.Overlay.Guides.Count == 1, + $"실제 {snapDoc.Overlay.Guides.Count}"); + var guide = snapDoc.Overlay.Guides.Count > 0 ? snapDoc.Overlay.Guides[0] : null; + Check("스냅: 가이드가 무한선이 아니라 선분이다", + guide is not null && guide.IsVertical && guide.Y2 - guide.Y1 < 1000, + guide is null ? "가이드 없음" : $"길이 {guide.Y2 - guide.Y1}"); + Check("스냅: 선분이 관련된 형제 전부를 덮는다", + guide is not null && guide.Y1 <= anchorTop.Y && guide.Y2 >= anchorBottom.Y + anchorBottom.Height, + guide is null ? "가이드 없음" : $"{guide.Y1}~{guide.Y2}"); + snapDoc.Interaction.PointerUp(new Point(grab.X + 3, grab.Y), none); + Check("스냅: 놓으면 표시가 사라진다", + snapDoc.Overlay.Guides.Count == 0 && snapDoc.Overlay.Spacings.Count == 0); + + // Alt 는 격자까지 전부 끈다 + var freeStart = Middle(mover); + var beforeX = mover.X; + snapDoc.Interaction.PointerDown(freeStart, none); + snapDoc.Interaction.PointerMove(new Point(freeStart.X + 3, freeStart.Y), alt); + Check("스냅: Alt 는 가이드를 내지 않는다", snapDoc.Overlay.Guides.Count == 0); + Check("스냅: Alt 는 정확히 그만큼 옮긴다", mover.X == beforeX + 3, $"실제 {mover.X}"); + snapDoc.Interaction.PointerUp(new Point(freeStart.X + 3, freeStart.Y), alt); + + // 간격 균등 — 30 간격 둘 뒤에 이어 붙는다 + var spacingDoc = new DesignerViewModel(business.CreateNew()); + Place(spacingDoc, "Label", 100, 600, 50, 20); + Place(spacingDoc, "Label", 180, 600, 50, 20); // 간격 30 + var third = Place(spacingDoc, "Label", 257, 600, 40, 20); // 260 이면 균등 + + var spacingGrab = Middle(third); + spacingDoc.Interaction.PointerDown(spacingGrab, none); + spacingDoc.Interaction.PointerMove(new Point(spacingGrab.X + 3, spacingGrab.Y), none); + Check("스냅: 같은 간격으로 이어 붙는다", third.X == 260, $"실제 {third.X}"); + Check("스냅: 간격 막대가 보인다", spacingDoc.Overlay.Spacings.Count >= 1, + $"실제 {spacingDoc.Overlay.Spacings.Count}"); + spacingDoc.Interaction.PointerUp(new Point(spacingGrab.X + 3, spacingGrab.Y), none); + + // 컨테이너 자식도 후보가 된다 / 컨테이너는 제 자식에게 붙지 않는다 + var nestDoc = new DesignerViewModel(business.CreateNew()); + var nestPanel = Place(nestDoc, "Panel", 100, 100, 300, 200) as ContainerViewModel; + if (nestPanel is not null) + { + nestDoc.Selection.SetSingle(nestPanel); + nestDoc.AddControlAt("Label", new Point(150, 150)); + var nestChild = nestPanel.Children.Count > 0 ? nestPanel.Children[^1] : null; + if (nestChild is not null) + { + nestChild.X = 50; // 월드 150 + nestChild.Y = 50; + nestChild.Width = 60; + nestChild.Height = 20; + + var outsider = Place(nestDoc, "Label", 147, 500, 60, 20); + nestDoc.Selection.SetSingle(outsider); + var outGrab = Middle(outsider); + nestDoc.Interaction.PointerDown(outGrab, none); + nestDoc.Interaction.PointerMove(new Point(outGrab.X + 3, outGrab.Y), none); + Check("스냅: 컨테이너 자식도 후보가 된다", outsider.X == 150, $"실제 {outsider.X}"); + nestDoc.Interaction.PointerUp(new Point(outGrab.X + 3, outGrab.Y), none); + + var panelBefore = nestPanel.X; + var panelGrab = new Point(nestPanel.X + 5, nestPanel.Y + 5); + nestDoc.Selection.SetSingle(nestPanel); + nestDoc.Interaction.PointerDown(panelGrab, none); + nestDoc.Interaction.PointerMove(new Point(panelGrab.X + 40, panelGrab.Y), none); + Check("스냅: 컨테이너는 제 자식에게 붙지 않는다", nestPanel.X != panelBefore, + $"실제 {nestPanel.X} (시작 {panelBefore})"); + nestDoc.Interaction.PointerUp(new Point(panelGrab.X + 40, panelGrab.Y), none); + } + } + + // 리사이즈 — 이동 드래그를 한 번도 안 한 상태에서 바로 핸들을 잡아도 붙어야 한다 + var resizeDoc = new DesignerViewModel(business.CreateNew()); + var wall = Place(resizeDoc, "Label", 300, 100, 60, 200); + var box = Place(resizeDoc, "Label", 100, 150, 100, 40); + resizeDoc.Selection.SetSingle(box); + resizeDoc.RefreshOverlay(); + + var eastHandle = new Point(box.X + box.Width, box.Y + box.Height / 2); + resizeDoc.Interaction.PointerDown(eastHandle, none); + resizeDoc.Interaction.PointerMove(new Point(298, eastHandle.Y), none); + Check("스냅: 리사이즈가 첫 드래그부터 형제 모서리에 붙는다", + box.X + box.Width == wall.X, $"실제 우변 {box.X + box.Width}"); + Check("스냅: 리사이즈에도 가이드가 보인다", resizeDoc.Overlay.Guides.Count >= 1, + $"실제 {resizeDoc.Overlay.Guides.Count}"); + resizeDoc.Interaction.PointerUp(new Point(298, eastHandle.Y), none); + Check("스냅: 리사이즈 후에도 표시가 사라진다", resizeDoc.Overlay.Guides.Count == 0); + } + // 25) 연속 Undo 로 빈 문서까지 var guard = 0; while (designer.Undo.CanUndo && guard++ < 80) diff --git a/src/SheetMe.Designer/Diagnostics/SnapShots.cs b/src/SheetMe.Designer/Diagnostics/SnapShots.cs new file mode 100644 index 0000000..76e095f --- /dev/null +++ b/src/SheetMe.Designer/Diagnostics/SnapShots.cs @@ -0,0 +1,190 @@ +using System.IO; +using System.Text; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using SheetMe.Designer.DataBusiness; +using SheetMe.Designer.Services; +using SheetMe.Designer.ViewModels; +using SheetMe.Designer.ViewModels.Controls; +using SheetMe.Designer.Views; + +namespace SheetMe.Designer.Diagnostics; + +/// +/// 스냅 표시 오프스크린 스냅샷 — --snap-shots <출력폴더>. +/// +/// 왜 필요한가. 기존 --render-smoke·--db-render 는 종이(PageView)만 찍어 +/// 오버레이가 안 나온다. 스냅은 "붙는 좌표"만 맞아서는 쓸 수 없다 — 선이 어디서 어디까지 그어지는지, +/// 여러 개가 동시에 보이는지, 간격 막대가 어떻게 생겼는지는 그림으로만 확인된다. +/// +/// 게이트는 수치로 건다. 같이 남기는 _report.txt 의 좌표·개수가 판정 기준이고 +/// PNG 는 눈 검증 보조다. 픽셀 비교는 테마·글꼴에 흔들려 회귀 게이트로 쓸 수 없다. +/// +/// 드래그 도중을 찍는다 — PointerUp 이 표시를 지우기 때문에 캡처는 반드시 그 전이다. +/// +public static class SnapShots +{ + #region Member Fields + private static readonly PointerContext Plain = new(false, false, false, 1); + #endregion + + #region Methods + public static int Run(string outputDirectory) + { + var lines = new List(); + try + { + Directory.CreateDirectory(outputDirectory); + Application.Current.ShutdownMode = ShutdownMode.OnExplicitShutdown; + ThemeManager.Apply(light: true); + + foreach (var (name, zoom, build) in Scenarios()) + { + var designer = new DesignerViewModel(new FormDesignDataBusiness().CreateNew()); + designer.Zoom = zoom; + var grab = build(designer); + + designer.Interaction.PointerDown(grab.From, Plain); + designer.Interaction.PointerMove(grab.To, Plain); + + Capture(designer, Path.Combine(outputDirectory, $"{name}.png")); + lines.Add($"{name} 줌={zoom:0.##} 가이드={designer.Overlay.Guides.Count} 간격={designer.Overlay.Spacings.Count}"); + foreach (var guide in designer.Overlay.Guides) + { + lines.Add($" 가이드 {(guide.IsVertical ? "세로" : "가로")} {guide.Position:0.##}" + + $" ({guide.X1:0.##},{guide.Y1:0.##})~({guide.X2:0.##},{guide.Y2:0.##})"); + } + foreach (var mark in designer.Overlay.Spacings) + { + lines.Add($" 간격 {mark.Text} ({mark.X1:0.##},{mark.Y1:0.##})~({mark.X2:0.##},{mark.Y2:0.##})"); + } + + designer.Interaction.PointerUp(grab.To, Plain); + if (designer.Overlay.Guides.Count != 0 || designer.Overlay.Spacings.Count != 0) + { + lines.Add($" FAIL 놓은 뒤에도 표시가 남았다"); + } + } + + var failed = lines.Count(l => l.Contains("FAIL", StringComparison.Ordinal)); + lines.Add($"결과: 실패 {failed}건"); + File.WriteAllText(Path.Combine(outputDirectory, "_report.txt"), + string.Join(Environment.NewLine, lines), Encoding.UTF8); + Console.Error.WriteLine(string.Join(Environment.NewLine, lines)); + return failed == 0 ? 0 : 1; + } + catch (Exception ex) + { + Console.Error.WriteLine($"스냅 스냅샷 실패 — {ex}"); + return 2; + } + } + + private readonly record struct Grab(Point From, Point To); + + private static IEnumerable<(string Name, double Zoom, Func Build)> Scenarios() + { + yield return ("01-형제-좌변", 1.0, d => + { + Place(d, "Label", 200, 100, 60, 20); + Place(d, "Label", 200, 400, 60, 20); + var mover = Place(d, "Label", 197, 250, 40, 20); + return Drag(d, mover, 3, 0); + }); + + yield return ("02-좌중우-동시", 1.0, d => + { + Place(d, "Label", 200, 120, 60, 20); + var mover = Place(d, "Label", 197, 300, 60, 20); + return Drag(d, mover, 3, 0); + }); + + yield return ("03-용지-중앙", 1.0, d => + { + var mover = Place(d, "Label", 334, 300, 40, 20); + return Drag(d, mover, 3, 0); + }); + + yield return ("04-간격-이어붙이기", 1.0, d => + { + Place(d, "Label", 100, 300, 50, 20); + Place(d, "Label", 180, 300, 50, 20); + var mover = Place(d, "Label", 257, 300, 40, 20); + return Drag(d, mover, 3, 0); + }); + + yield return ("05-간격-사이끼우기", 1.0, d => + { + Place(d, "Label", 100, 300, 50, 20); + Place(d, "Label", 300, 300, 50, 20); + var mover = Place(d, "Label", 202, 300, 40, 20); + return Drag(d, mover, 3, 0); + }); + + yield return ("06-줌-절반", 0.5, d => + { + // 컨트롤을 높게 잡는다 — 줌 0.5 에서는 핸들 판정 반경이 12 라 + // 높이 20 짜리를 가운데서 잡으면 상단 핸들에 먼저 걸려 리사이즈로 빠진다 + Place(d, "Label", 200, 100, 60, 40); + Place(d, "Label", 200, 400, 60, 40); + var mover = Place(d, "Label", 190, 250, 40, 40); + return Drag(d, mover, 4, 0); + }); + + yield return ("07-줌-두배", 2.0, d => + { + Place(d, "Label", 200, 100, 60, 20); + Place(d, "Label", 200, 400, 60, 20); + var mover = Place(d, "Label", 198, 250, 40, 20); + return Drag(d, mover, 3, 0); + }); + } + + private static ControlViewModel Place(DesignerViewModel designer, string type, + double x, double y, double w, double h) + { + designer.AddControlAt(type, new Point(x, y)); + var vm = designer.Pages[0].Controls[^1]; + vm.X = x; + vm.Y = y; + vm.Width = w; + vm.Height = h; + return vm; + } + + private static Grab Drag(DesignerViewModel designer, ControlViewModel mover, double dx, double dy) + { + designer.Selection.SetSingle(mover); + designer.RefreshOverlay(); + var from = new Point(mover.X + mover.Width / 2, mover.Y + mover.Height / 2); + return new Grab(from, new Point(from.X + dx, from.Y + dy)); + } + + /// 종이 위에 오버레이를 그대로 겹쳐 찍는다 — 1페이지 문서라 월드 좌표가 곧 종이 좌표다 + private static void Capture(DesignerViewModel designer, string pngPath) + { + var page = designer.Pages[0]; + var width = page.WidthDip; + var height = page.HeightDip; + + var root = new Grid { Width = width, Height = height, Background = Brushes.White }; + root.Children.Add(new PageView { DataContext = page }); + root.Children.Add(new SelectionOverlayView { DataContext = designer.Overlay }); + + root.Measure(new Size(width, height)); + root.Arrange(new Rect(0, 0, width, height)); + root.UpdateLayout(); + + var bitmap = new RenderTargetBitmap( + (int)Math.Ceiling(width), (int)Math.Ceiling(height), 96, 96, PixelFormats.Pbgra32); + bitmap.Render(root); + + var encoder = new PngBitmapEncoder(); + encoder.Frames.Add(BitmapFrame.Create(bitmap)); + using var stream = File.Create(pngPath); + encoder.Save(stream); + } + #endregion +} diff --git a/src/SheetMe.Designer/Services/InteractionController.cs b/src/SheetMe.Designer/Services/InteractionController.cs index de7ba12..4268f0f 100644 --- a/src/SheetMe.Designer/Services/InteractionController.cs +++ b/src/SheetMe.Designer/Services/InteractionController.cs @@ -1,4 +1,5 @@ using System.Windows; +using SheetMe.Core.Layout; using SheetMe.Designer.ViewModels; using SheetMe.Designer.ViewModels.Controls; @@ -78,6 +79,9 @@ public sealed class InteractionController mode = Mode.Resize; resizeHandleIndex = handleIndex; CaptureOrigBounds(); + // 리사이즈도 후보를 모아야 한다. 예전에는 여기서 안 모아서, 이동 드래그를 한 번 한 뒤라야 + // 리사이즈 스냅이 — 그것도 그때의 낡은 좌표로 — 동작했다. + BeginSnap(); return; } @@ -188,11 +192,13 @@ public sealed class InteractionController case Mode.Move: designer.ReassignPagesAfterMove(origBounds.Keys.ToList()); - designer.Overlay.SetGuides(null, null); + designer.Overlay.ClearGuides(); + designer.Snap.EndDrag(); break; case Mode.Resize: - designer.Overlay.SetGuides(null, null); + designer.Overlay.ClearGuides(); + designer.Snap.EndDrag(); break; case Mode.Marquee: @@ -236,7 +242,8 @@ public sealed class InteractionController vm.Width = rect.Width; vm.Height = rect.Height; } - designer.Overlay.SetGuides(null, null); + designer.Overlay.ClearGuides(); + designer.Snap.EndDrag(); mode = Mode.None; origBounds.Clear(); designer.RefreshOverlay(); @@ -287,16 +294,60 @@ public sealed class InteractionController #endregion #region Methods - Private + /// 리사이즈로 맞은 모서리를 선분 가이드로 — 이동 때와 같은 모양으로 보여야 한다 + private static IReadOnlyList EdgeGuides(SnapEdgeOutcome? hitX, SnapEdgeOutcome? hitY, Rect rect) + { + if (hitX is not { Snapped: true } && hitY is not { Snapped: true }) + { + return Array.Empty(); + } + var list = new List(2); + if (hitX is { Snapped: true } x) + { + var start = rect.Top; + var end = rect.Bottom; + foreach (var source in x.Matched) + { + start = Math.Min(start, source.Top); + end = Math.Max(end, source.Bottom); + } + list.Add(new SnapGuide(true, x.Value, start, end, x.Kind)); + } + if (hitY is { Snapped: true } y) + { + var start = rect.Left; + var end = rect.Right; + foreach (var source in y.Matched) + { + start = Math.Min(start, source.Left); + end = Math.Max(end, source.Right); + } + list.Add(new SnapGuide(false, y.Value, start, end, y.Kind)); + } + return list; + } + private void BeginMove() { CaptureOrigBounds(); + BeginSnap(); + } + + /// + /// 스냅 후보 수집 — 이동·리사이즈 공용. + /// + /// 제외 집합은 선택 항목만으로는 모자라다. 끌려가는 컨테이너의 자식은 선택에 없지만 함께 움직이므로, + /// 빼지 않으면 컨테이너가 제 자식에게 붙어 그 자리에서 굳는다. + /// + private void BeginSnap() + { // Primary 는 없을 수 있다(선택 항목은 있는데 주선택이 비는 경로가 있다) — // ?! 로 넘기면 PageOf → RootAncestorOf 가 즉시 역참조해 이동 시작이 예외로 죽는다 var anchor = designer.Selection.Primary ?? designer.Selection.Items.FirstOrDefault(); var page = (anchor is null ? null : designer.PageOf(anchor)) ?? designer.Pages.FirstOrDefault(); if (page is not null) { - designer.Snap.BeginDrag(page, designer.Selection.Items.ToHashSet()); + designer.Snap.BeginDrag(designer, page, designer.SelectionWithDescendants()); } } @@ -307,15 +358,20 @@ public sealed class InteractionController var dx = world.X - downPoint.X; var dy = world.Y - downPoint.Y; - var snap = designer.Snap.SnapMove(groupBounds0, dx, dy, ctx.Alt); - designer.Overlay.SetGuides(snap.GuideX, snap.GuideY); + var snap = designer.Snap.SnapMove(groupBounds0, dx, dy, ctx.Alt, designer.Zoom); + designer.Overlay.SetGuides(snap.Guides, snap.Spacings); // origBounds 는 월드 좌표 — 로컬 = (원본 월드 + 보정 델타) - 부모 체인 오프셋 foreach (var (vm, rect) in origBounds) { var offset = designer.ParentWorldOffset(vm); - vm.X = Math.Round(rect.X + snap.Dx - offset.X); - vm.Y = Math.Round(rect.Y + snap.Dy - offset.Y); + var x = rect.X + snap.Dx - offset.X; + var y = rect.Y + snap.Dy - offset.Y; + // 정합된 축은 반올림하지 않는다. 형제 폭이 홀수면 중심이 반정수라, 여기서 반올림하면 + // 중앙에 맞췄는데 0.5px 어긋난 채로 놓이고 가이드선이 모서리에서 떠 보인다. + // 저장은 LegacyFormat.FormatPair 가 어차피 정수로 쓰므로 포맷은 상관없다. + vm.X = snap.SnappedX ? x : Math.Round(x); + vm.Y = snap.SnappedY ? y : Math.Round(y); } designer.Selection.NotifyBoundsChanged(); @@ -332,21 +388,27 @@ public sealed class InteractionController var bottom = rect.Bottom; // 핸들별 이동 모서리 (0=NW,1=N,2=NE,3=E,4=SE,5=S,6=SW,7=W) + SnapEdgeOutcome? hitX = null; + SnapEdgeOutcome? hitY = null; if (resizeHandleIndex is 0 or 6 or 7) { - left = designer.Snap.SnapEdge(world.X, isXAxis: true, ctx.Alt); + hitX = designer.Snap.SnapEdge(world.X, isXAxis: true, ctx.Alt, designer.Zoom); + left = hitX.Value.Value; } if (resizeHandleIndex is 2 or 3 or 4) { - right = designer.Snap.SnapEdge(world.X, isXAxis: true, ctx.Alt); + hitX = designer.Snap.SnapEdge(world.X, isXAxis: true, ctx.Alt, designer.Zoom); + right = hitX.Value.Value; } if (resizeHandleIndex is 0 or 1 or 2) { - top = designer.Snap.SnapEdge(world.Y, isXAxis: false, ctx.Alt); + hitY = designer.Snap.SnapEdge(world.Y, isXAxis: false, ctx.Alt, designer.Zoom); + top = hitY.Value.Value; } if (resizeHandleIndex is 4 or 5 or 6) { - bottom = designer.Snap.SnapEdge(world.Y, isXAxis: false, ctx.Alt); + hitY = designer.Snap.SnapEdge(world.Y, isXAxis: false, ctx.Alt, designer.Zoom); + bottom = hitY.Value.Value; } var newRect = new Rect( @@ -355,6 +417,10 @@ public sealed class InteractionController Math.Max(MinSize, right - left), Math.Max(MinSize, bottom - top)); + // 선분은 최종 사각형이 정해진 뒤에 조립한다 — 교차축도 스냅으로 바뀔 수 있어서, + // 스냅 계산 시점의 좌표로 범위를 만들면 선이 어긋난 자리에 걸린다. + designer.Overlay.SetGuides(EdgeGuides(hitX, hitY, newRect), Array.Empty()); + // 그룹 비례 스케일 — origBounds 기준 절대 재계산 var sx = newRect.Width / Math.Max(1, groupBounds0.Width); var sy = newRect.Height / Math.Max(1, groupBounds0.Height); @@ -409,7 +475,8 @@ public sealed class InteractionController var positions = SelectionOverlayViewModel.HandlePositions(bbox); // 반경 내 '최근접' 핸들 선택 — 작은 컨트롤에서 인접 핸들 오인 방지 - const double hitRadius = 6; + // 화면 기준 6px — 월드 고정이면 줌 300%에서 그림은 8px 인데 판정이 18px 로 벌어진다 + var hitRadius = 6 / designer.Zoom; var best = -1; var bestDistance = double.MaxValue; for (var i = 0; i < positions.Length; i++) diff --git a/src/SheetMe.Designer/Services/SnapEngine.cs b/src/SheetMe.Designer/Services/SnapEngine.cs index 4a62fd9..76fe7f0 100644 --- a/src/SheetMe.Designer/Services/SnapEngine.cs +++ b/src/SheetMe.Designer/Services/SnapEngine.cs @@ -1,125 +1,86 @@ using System.Windows; +using SheetMe.Core.Layout; using SheetMe.Designer.ViewModels; using SheetMe.Designer.ViewModels.Controls; namespace SheetMe.Designer.Services; -/// 스냅 결과 — 보정된 이동량과 표시할 가이드 좌표(월드) -public readonly record struct SnapResult(double Dx, double Dy, double? GuideX, double? GuideY); - /// -/// 그리드/정렬 스냅 순수 계산. -/// 드래그 시작 시 후보(비선택 형제의 좌/중/우·상/중/하 + 용지 경계/중앙)를 1회 사전수집해 -/// 프레임당 재수집을 피한다. +/// 스냅 — 뷰모델과 순수 계산() 사이의 얇은 어댑터. +/// +/// 왜 계산이 여기 없는가. 스냅 규칙은 눈으로만 확인되는 종류의 코드다 — 후보 하나, +/// 열거 순서 하나가 바뀌면 붙는 자리가 조용히 달라지고 드래그해 보기 전엔 아무도 모른다. +/// 그래서 판단은 전부 SheetMe.Core 로 옮겨 단위 테스트로 못 박고, 여기에는 +/// "어떤 사각형들이 후보인가"와 좌표 변환만 남긴다. +/// +/// 허용 오차는 화면 픽셀이다. 월드 고정이면 줌 50%에서 두 배로 끈적이고 200%에서 절반으로 +/// 미끄러진다 — 손끝 감각은 화면 거리로 정해진다. /// public sealed class SnapEngine { #region Member Fields - private readonly List candidatesX = new(); - private readonly List candidatesY = new(); + private readonly SnapSolver solver = new(); #endregion #region Properties - /// 그리드 간격(px) + /// 정렬이 실패한 축의 폴백 격자(월드 px) public double GridSize { get; set; } = 4; - /// 정렬 스냅 허용 거리(px) - public double Tolerance { get; set; } = 6; + /// 정렬 허용 거리 — 화면 px + public double ScreenTolerance { get; set; } = 6; + + /// 간격 균등 스냅 사용 + public bool EnableSpacing { get; set; } = true; #endregion #region Methods - /// 드래그 시작 — 스냅 후보 사전수집(월드 좌표) - public void BeginDrag(PageViewModel page, IReadOnlySet moving) + /// + /// 드래그 시작 — 후보를 한 번만 모은다. + /// + /// 후보에는 컨테이너 자식까지 넣는다. 히트테스트는 재귀하는데 스냅만 최상위를 보던 것은 + /// 규칙 불일치였다 — 패널 안 라벨에 맞추려 해도 붙지 않았다. + /// 잠긴 컨트롤은 후보로 남긴다(고정 기준선으로 쓰는 것이 맞다). 숨긴 것만 뺀다. + /// + public void BeginDrag(DesignerViewModel designer, PageViewModel page, + IReadOnlySet moving) { - candidatesX.Clear(); - candidatesY.Clear(); - - // 용지 경계·중앙 - candidatesX.Add(0); - candidatesX.Add(page.WidthDip / 2); - candidatesX.Add(page.WidthDip); - candidatesY.Add(page.OffsetY); - candidatesY.Add(page.OffsetY + page.HeightDip / 2); - candidatesY.Add(page.OffsetY + page.HeightDip); - - foreach (var sibling in page.Controls) + var siblings = new List(); + foreach (var vm in designer.ControlsOfPage(page)) { - if (moving.Contains(sibling) || sibling.Model.Hidden) + // 끌려가는 컨테이너의 자식은 선택 목록에 없지만 부모를 따라 움직인다 — + // 빼지 않으면 자기 자신에게 붙는다 + if (moving.Contains(vm) || vm.Model.Hidden) { continue; } - candidatesX.Add(sibling.X); - candidatesX.Add(sibling.X + sibling.Width / 2); - candidatesX.Add(sibling.X + sibling.Width); - - var top = page.OffsetY + sibling.Y; - candidatesY.Add(top); - candidatesY.Add(top + sibling.Height / 2); - candidatesY.Add(top + sibling.Height); + siblings.Add(ToSnapRect(designer.WorldBoundsOf(vm))); } + + var paper = new SnapRect(0, page.OffsetY, page.WidthDip, page.HeightDip); + solver.Prepare(new SnapContext + { + Pages = new[] { paper }, + Siblings = siblings, + // 페이지를 넘는 '균등 간격'은 뜻이 없다 + SpacingPage = paper, + }); } - /// - /// 이동 스냅 — bbox(월드)에 (dx,dy) 적용 시 정렬 후보와 최근접 정합. - /// free=true(Alt)면 스냅 없이 원본 이동량 그대로. - /// - public SnapResult SnapMove(Rect bbox, double dx, double dy, bool free) - { - if (free) - { - return new SnapResult(dx, dy, null, null); - } + /// 드래그 끝 — 후보를 버린다. 남겨 두면 다음 드래그가 낡은 좌표에 붙는다 + public void EndDrag() => solver.Reset(); - var movedLeft = bbox.X + dx; - var movedTop = bbox.Y + dy; + /// 이동 스냅 — bbox(월드)에 (dx,dy) 를 적용한 자리에서 정렬·간격·격자 순으로 붙인다 + public SnapOutcome SnapMove(Rect bbox, double dx, double dy, bool free, double zoom) + => solver.SolveMove(ToSnapRect(bbox), dx, dy, OptionsFor(zoom), free); - var (adjustX, guideX) = SnapAxis(new[] { movedLeft, movedLeft + bbox.Width / 2, movedLeft + bbox.Width }, candidatesX); - var (adjustY, guideY) = SnapAxis(new[] { movedTop, movedTop + bbox.Height / 2, movedTop + bbox.Height }, candidatesY); + /// 리사이즈 모서리 스냅 + public SnapEdgeOutcome SnapEdge(double value, bool isXAxis, bool free, double zoom) + => solver.SolveEdge(value, isXAxis, OptionsFor(zoom), free); - // 정합 실패 축은 그리드 스냅 - var resultDx = guideX is not null ? dx + adjustX : Math.Round(movedLeft / GridSize) * GridSize - bbox.X; - var resultDy = guideY is not null ? dy + adjustY : Math.Round(movedTop / GridSize) * GridSize - bbox.Y; + private SnapOptions OptionsFor(double zoom) + => SnapOptions.ForZoom(ScreenTolerance, GridSize, zoom, EnableSpacing); - return new SnapResult(resultDx, resultDy, guideX, guideY); - } - - /// 리사이즈 스냅 — 움직이는 모서리 좌표만 정합(간이: 그리드 우선) - public double SnapEdge(double value, bool isXAxis, bool free) - { - if (free) - { - return value; - } - var candidates = isXAxis ? candidatesX : candidatesY; - foreach (var candidate in candidates) - { - if (Math.Abs(candidate - value) <= Tolerance) - { - return candidate; - } - } - return Math.Round(value / GridSize) * GridSize; - } - - private (double Adjust, double? Guide) SnapAxis(double[] edges, List candidates) - { - var best = double.MaxValue; - double adjust = 0; - double? guide = null; - foreach (var edge in edges) - { - foreach (var candidate in candidates) - { - var distance = candidate - edge; - if (Math.Abs(distance) <= Tolerance && Math.Abs(distance) < Math.Abs(best)) - { - best = distance; - adjust = distance; - guide = candidate; - } - } - } - return (adjust, guide); - } + private static SnapRect ToSnapRect(Rect rect) + => new(rect.X, rect.Y, rect.Width, rect.Height); #endregion } diff --git a/src/SheetMe.Designer/Themes/Tokens.Dark.xaml b/src/SheetMe.Designer/Themes/Tokens.Dark.xaml index 1de825b..0f97947 100644 --- a/src/SheetMe.Designer/Themes/Tokens.Dark.xaml +++ b/src/SheetMe.Designer/Themes/Tokens.Dark.xaml @@ -49,6 +49,11 @@ + + + + diff --git a/src/SheetMe.Designer/Themes/Tokens.Light.xaml b/src/SheetMe.Designer/Themes/Tokens.Light.xaml index b355c41..b1206f2 100644 --- a/src/SheetMe.Designer/Themes/Tokens.Light.xaml +++ b/src/SheetMe.Designer/Themes/Tokens.Light.xaml @@ -83,6 +83,11 @@ + + + + diff --git a/src/SheetMe.Designer/ViewModels/DesignerViewModel.cs b/src/SheetMe.Designer/ViewModels/DesignerViewModel.cs index be54821..25bedc9 100644 --- a/src/SheetMe.Designer/ViewModels/DesignerViewModel.cs +++ b/src/SheetMe.Designer/ViewModels/DesignerViewModel.cs @@ -239,6 +239,8 @@ public sealed class DesignerViewModel : ViewModelBase if (SetProperty(ref zoom, clamped)) { OnPropertyChanged(nameof(ZoomPercentText)); + // 오버레이 선 두께를 화면 1px 로 유지하려면 오버레이가 배율을 알아야 한다 + Overlay.Zoom = clamped; } } } @@ -270,7 +272,7 @@ public sealed class DesignerViewModel : ViewModelBase Snap = new SnapEngine { GridSize = ConfigService.Current.GridSize, - Tolerance = ConfigService.Current.SnapThreshold, + ScreenTolerance = ConfigService.Current.SnapThreshold, }; Undo = new UndoService(() => Document, ReplaceDocument); Interaction = new InteractionController(this); @@ -953,6 +955,51 @@ public sealed class DesignerViewModel : ViewModelBase public IReadOnlyList ControlNames() => AllControls().Select(c => c.Id).Where(id => id.Length > 0).Distinct(StringComparer.Ordinal).ToList(); + /// + /// 한 페이지의 컨트롤 순회(컨테이너 자식 포함) — 스냅 후보 수집용. + /// 스냅은 앵커 페이지 안에서만 본다. 전 페이지를 넣으면 후보가 폭발하고, + /// 다른 종이의 좌표에 붙는 것은 뜻도 없다. + /// + public IEnumerable ControlsOfPage(PageViewModel page) + { + foreach (var vm in page.Controls) + { + foreach (var descendant in Descend(vm)) + { + yield return descendant; + } + } + } + + /// 선택 항목과 그 자손 전부 — 끌려가는 컨테이너의 자식을 스냅 후보에서 빼는 데 쓴다 + public HashSet SelectionWithDescendants() + { + var set = new HashSet(); + foreach (var item in Selection.Items) + { + foreach (var vm in Descend(item)) + { + set.Add(vm); + } + } + return set; + } + + private static IEnumerable Descend(ControlViewModel viewModel) + { + yield return viewModel; + if (viewModel is ContainerViewModel container) + { + foreach (var child in container.Children) + { + foreach (var descendant in Descend(child)) + { + yield return descendant; + } + } + } + } + /// 문서 전체 컨트롤 순회(컨테이너 자식 포함, 모델 순서) private IEnumerable AllControls() { diff --git a/src/SheetMe.Designer/ViewModels/SelectionOverlayViewModel.cs b/src/SheetMe.Designer/ViewModels/SelectionOverlayViewModel.cs index 77a6f31..faf1689 100644 --- a/src/SheetMe.Designer/ViewModels/SelectionOverlayViewModel.cs +++ b/src/SheetMe.Designer/ViewModels/SelectionOverlayViewModel.cs @@ -1,16 +1,58 @@ using System.Collections.ObjectModel; using System.Windows; +using SheetMe.Core.Layout; namespace SheetMe.Designer.ViewModels; -/// 오버레이 가이드선 1개 — 월드 좌표 수직/수평선 +/// +/// 오버레이 가이드선 1개 — 월드 좌표 선분(양끝). +/// +/// 예전에는 위치 하나만 들고 화면 끝에서 끝까지(±100000) 그었다. 그러면 "무엇에 맞춘 것인지"가 +/// 안 보인다 — 종이 밖 회색 배경까지 선이 뻗어 대비도 죽었다. 관련된 것들만 잇는다. +/// public sealed class GuideLineInfo { - /// 수직선 여부(false=수평선) - public bool IsVertical { get; init; } + public double X1 { get; init; } + public double Y1 { get; init; } + public double X2 { get; init; } + public double Y2 { get; init; } - /// 선 위치(월드 X 또는 Y) - public double Position { get; init; } + /// 수직선 여부 — 진단·테스트용 파생(뷰는 X1..Y2 만 쓴다) + public bool IsVertical => Math.Abs(X1 - X2) < 0.001; + + /// 정합 좌표 — 진단·테스트용 파생 + public double Position => IsVertical ? X1 : Y1; +} + +/// +/// 간격 균등 표시 1개 — 막대 하나와 양끝 갈고리 둘. 전부 월드 좌표. +/// 좌표를 여기서 다 구워 두는 것은 이 저장소 규약이다( 와 같다) — +/// XAML 에서는 산술을 할 수 없다. +/// +public sealed class SpacingMarkInfo +{ + public double X1 { get; init; } + public double Y1 { get; init; } + public double X2 { get; init; } + public double Y2 { get; init; } + + /// 시작 쪽 갈고리 + public double CapAX1 { get; init; } + public double CapAY1 { get; init; } + public double CapAX2 { get; init; } + public double CapAY2 { get; init; } + + /// 끝 쪽 갈고리 + public double CapBX1 { get; init; } + public double CapBY1 { get; init; } + public double CapBX2 { get; init; } + public double CapBY2 { get; init; } + + /// 간격값 표시 + public string Text { get; init; } = string.Empty; + + public double TextX { get; init; } + public double TextY { get; init; } } /// 탭순서 배지 1개 — 월드 좌표(컨트롤 좌상단) @@ -63,6 +105,7 @@ public sealed class SelectionOverlayViewModel : ViewModelBase private double marY; private double marW; private double marH; + private double zoom = 1; #endregion #region Properties @@ -105,6 +148,28 @@ public sealed class SelectionOverlayViewModel : ViewModelBase /// 정렬 가이드선 목록 public ObservableCollection Guides { get; } = new(); + /// 간격 균등 표시 목록 + public ObservableCollection Spacings { get; } = new(); + + /// + /// 캔버스 줌 — 오버레이는 줌이 걸린 층에 얹혀 있어서, 선을 화면 1px 로 유지하려면 + /// 두께에 이 역수를 걸어야 한다. 갈고리 길이도 같은 이유로 이걸 쓴다. + /// + public double Zoom + { + get => zoom; + set + { + if (SetProperty(ref zoom, value <= 0 ? 1 : value)) + { + OnPropertyChanged(nameof(InverseZoom)); + } + } + } + + /// 화면 1px 에 해당하는 월드 길이 + public double InverseZoom => 1.0 / zoom; + /// 탭순서 배지 목록(탭순서 편집 모드 전용) public ObservableCollection TabBadges { get; } = new(); #endregion @@ -170,18 +235,115 @@ public sealed class SelectionOverlayViewModel : ViewModelBase MarH = rect.Value.Height; } - /// 가이드선 교체 - public void SetGuides(double? guideX, double? guideY) + /// 가이드·간격 표시 지우기 + public void ClearGuides() { - Guides.Clear(); - if (guideX is not null) + if (Guides.Count > 0) { - Guides.Add(new GuideLineInfo { IsVertical = true, Position = guideX.Value }); + Guides.Clear(); } - if (guideY is not null) + if (Spacings.Count > 0) { - Guides.Add(new GuideLineInfo { IsVertical = false, Position = guideY.Value }); + Spacings.Clear(); } } + + /// + /// 스냅 결과를 표시형으로 — 계산은 가 끝냈고 + /// 여기서는 그리기 좌표만 굽는다. + /// + /// 내용이 이전과 같으면 컬렉션을 건드리지 않는다. 드래그는 프레임마다 들어오는데 + /// 매번 Clear+Add 하면 ItemsControl 이 컨테이너를 통째로 다시 만든다. + /// + public void SetGuides(IReadOnlyList guides, IReadOnlyList spacings) + { + if (!SameGuides(guides)) + { + Guides.Clear(); + foreach (var guide in guides) + { + Guides.Add(guide.IsVertical + ? new GuideLineInfo { X1 = guide.Position, X2 = guide.Position, Y1 = guide.Start, Y2 = guide.End } + : new GuideLineInfo { Y1 = guide.Position, Y2 = guide.Position, X1 = guide.Start, X2 = guide.End }); + } + } + + if (SameSpacings(spacings)) + { + return; + } + Spacings.Clear(); + // 갈고리는 화면 4px — 줌이 걸린 층이라 월드 길이로 환산해 굽는다 + var cap = 4 * InverseZoom; + foreach (var mark in spacings) + { + var mid = (mark.Start + mark.End) / 2; + var text = FormatGap(mark.Gap); + // 칩은 좌상단 기준으로 놓이므로 중심 보정을 여기서 넣는다(뷰 설명 참조). + // 폭은 글꼴을 재지 않고 글자 수로 어림한다 — 1~4자짜리 숫자라 오차가 눈에 안 띈다. + var halfWidth = (4 + 3.4 * text.Length) * InverseZoom; + var halfHeight = 7 * InverseZoom; + Spacings.Add(mark.IsHorizontal + ? new SpacingMarkInfo + { + X1 = mark.Start, Y1 = mark.Cross, X2 = mark.End, Y2 = mark.Cross, + CapAX1 = mark.Start, CapAY1 = mark.Cross - cap, CapAX2 = mark.Start, CapAY2 = mark.Cross + cap, + CapBX1 = mark.End, CapBY1 = mark.Cross - cap, CapBX2 = mark.End, CapBY2 = mark.Cross + cap, + Text = text, TextX = mid - halfWidth, TextY = mark.Cross - halfHeight, + } + : new SpacingMarkInfo + { + X1 = mark.Cross, Y1 = mark.Start, X2 = mark.Cross, Y2 = mark.End, + CapAX1 = mark.Cross - cap, CapAY1 = mark.Start, CapAX2 = mark.Cross + cap, CapAY2 = mark.Start, + CapBX1 = mark.Cross - cap, CapBY1 = mark.End, CapBX2 = mark.Cross + cap, CapBY2 = mark.End, + Text = text, TextX = mark.Cross - halfWidth, TextY = mid - halfHeight, + }); + } + } + + private static string FormatGap(double gap) => $"{Math.Round(gap):0}"; + + private bool SameGuides(IReadOnlyList guides) + { + if (Guides.Count != guides.Count) + { + return false; + } + for (var i = 0; i < guides.Count; i++) + { + var a = Guides[i]; + var b = guides[i]; + var x1 = b.IsVertical ? b.Position : b.Start; + var y1 = b.IsVertical ? b.Start : b.Position; + var x2 = b.IsVertical ? b.Position : b.End; + var y2 = b.IsVertical ? b.End : b.Position; + if (Math.Abs(a.X1 - x1) > 0.001 || Math.Abs(a.Y1 - y1) > 0.001 + || Math.Abs(a.X2 - x2) > 0.001 || Math.Abs(a.Y2 - y2) > 0.001) + { + return false; + } + } + return true; + } + + private bool SameSpacings(IReadOnlyList spacings) + { + if (Spacings.Count != spacings.Count) + { + return false; + } + for (var i = 0; i < spacings.Count; i++) + { + var a = Spacings[i]; + var b = spacings[i]; + var x1 = b.IsHorizontal ? b.Start : b.Cross; + var y1 = b.IsHorizontal ? b.Cross : b.Start; + if (Math.Abs(a.X1 - x1) > 0.001 || Math.Abs(a.Y1 - y1) > 0.001) + { + return false; + } + } + return true; + } #endregion } diff --git a/src/SheetMe.Designer/Views/SelectionOverlayView.xaml b/src/SheetMe.Designer/Views/SelectionOverlayView.xaml index e57f163..6f38576 100644 --- a/src/SheetMe.Designer/Views/SelectionOverlayView.xaml +++ b/src/SheetMe.Designer/Views/SelectionOverlayView.xaml @@ -4,6 +4,7 @@ xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:vm="clr-namespace:SheetMe.Designer.ViewModels" + xmlns:v="clr-namespace:SheetMe.Designer.Views" mc:Ignorable="d" d:DataContext="{d:DesignInstance vm:SelectionOverlayViewModel}" IsHitTestVisible="False"> @@ -11,39 +12,6 @@ - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/SheetMe.Core.Tests/SnapSolverTests.cs b/tests/SheetMe.Core.Tests/SnapSolverTests.cs new file mode 100644 index 0000000..b81f114 --- /dev/null +++ b/tests/SheetMe.Core.Tests/SnapSolverTests.cs @@ -0,0 +1,373 @@ +using SheetMe.Core.Layout; + +namespace SheetMe.Core.Tests; + +/// +/// 스냅 계산 고정 — 손에 닿는 감각을 숫자로 못 박는다. +/// +/// 스냅은 "어쩐지 잘 붙는다"로는 지킬 수 없다. 후보가 하나 늘거나 열거 순서가 바뀌는 것만으로 +/// 붙는 자리가 조용히 달라지고, 그건 드래그해 보기 전엔 아무도 모른다. +/// 그래서 승자 규칙·가이드 개수·선분 범위·간격 균등을 전부 여기서 고정한다. +/// +[TestClass] +public sealed class SnapSolverTests +{ + #region Member Fields + private static readonly SnapRect Page = new(0, 0, 720, 856); + private static readonly SnapOptions Options = new(Tolerance: 6, GridSize: 4, EnableSpacing: true); + private static readonly SnapOptions NoSpacing = Options with { EnableSpacing = false }; + #endregion + + #region Methods + private static SnapSolver Solver(params SnapRect[] siblings) + { + var solver = new SnapSolver(); + solver.Prepare(new SnapContext + { + Pages = new[] { Page }, + Siblings = siblings, + SpacingPage = Page, + }); + return solver; + } + + // ── 정렬 ─────────────────────────────────────────────────────────── + + [TestMethod] + public void 형제_좌변에_붙는다() + { + // 형제 폭을 81 로 잡아 중심(140.5)이 이동체 우변(137)과 '같은 거리'가 되지 않게 한다 — + // 80 이면 중심이 140 이라 우변도 정확히 +3 이 되어 가이드가 둘 나온다(그건 그것대로 옳다) + var solver = Solver(new SnapRect(100, 50, 81, 20)); + var result = solver.SolveMove(new SnapRect(0, 200, 40, 10), 97, 0, NoSpacing, free: false); + + Assert.IsTrue(result.SnappedX); + Assert.AreEqual(100, 0 + result.Dx, 1e-9, "좌변이 형제 좌변에 맞아야 한다"); + Assert.AreEqual(1, result.Guides.Count); + var guide = result.Guides[0]; + Assert.IsTrue(guide.IsVertical); + Assert.AreEqual(100, guide.Position, 1e-9); + Assert.AreEqual(SnapGuideKind.SiblingEdge, guide.Kind); + // 선분은 형제와 이동체를 모두 덮는 만큼만 — 화면을 가로지르지 않는다 + Assert.AreEqual(50, guide.Start, 1e-9); + Assert.AreEqual(210, guide.End, 1e-9); + } + + [TestMethod] + public void 허용오차_경계는_포함이고_그_바깥은_격자로_떨어진다() + { + var solver = Solver(new SnapRect(100, 50, 80, 20)); + + var onEdge = solver.SolveMove(new SnapRect(0, 200, 40, 10), 94, 0, NoSpacing, free: false); + Assert.IsTrue(onEdge.SnappedX, "거리 6은 붙는다"); + + var justOutside = solver.SolveMove(new SnapRect(0, 200, 40, 10), 93.999, 0, NoSpacing, free: false); + Assert.IsFalse(justOutside.SnappedX, "거리 6.001 은 안 붙는다"); + Assert.AreEqual(0, result4(justOutside.Dx) % 4, "정합 실패 축은 4px 격자"); + Assert.AreEqual(0, justOutside.Guides.Count); + + static double result4(double dx) => Math.Round(dx, 6); + } + + [TestMethod] + public void 같은_좌표의_형제_둘은_가이드_하나로_합쳐지고_범위가_넓어진다() + { + var solver = Solver(new SnapRect(100, 0, 50, 20), new SnapRect(100, 300, 50, 20)); + var result = solver.SolveMove(new SnapRect(0, 200, 40, 10), 97, 0, NoSpacing, free: false); + + Assert.AreEqual(1, result.Guides.Count, "같은 자리에 선을 겹쳐 긋지 않는다"); + Assert.AreEqual(0, result.Guides[0].Start, 1e-9); + Assert.AreEqual(320, result.Guides[0].End, 1e-9); + } + + [TestMethod] + public void 서로_다른_자리에_동시에_맞으면_가이드가_둘이다() + { + // 이동체 폭 40. Left=100 에 형제 A 의 좌변, Right=140 에 형제 B 의 좌변 + var solver = Solver(new SnapRect(100, 0, 50, 20), new SnapRect(140, 400, 50, 20)); + var result = solver.SolveMove(new SnapRect(0, 200, 40, 10), 97, 0, NoSpacing, free: false); + + Assert.IsTrue(result.SnappedX); + Assert.AreEqual(2, result.Guides.Count); + CollectionAssert.AreEquivalent( + new[] { 100.0, 140.0 }, + result.Guides.Select(g => g.Position).ToArray()); + } + + [TestMethod] + public void 거리가_같아도_부호가_반대면_한쪽만_그린다() + { + // 이동 후 Left=100 기준: 형제 A 좌변 103(+3), 형제 B 좌변 97(−3). + // 형제를 넓게 잡아 중심·우변이 사정권에 안 들어오게 한다(들어오면 더 가까운 매치가 승자가 된다) + var solver = Solver(new SnapRect(103, 0, 200, 20), new SnapRect(97, 400, 200, 20)); + var result = solver.SolveMove(new SnapRect(0, 200, 40, 10), 100, 0, NoSpacing, free: false); + + Assert.IsTrue(result.SnappedX); + Assert.AreEqual(1, result.Guides.Count, + "보정 후 실제로 맞는 것만 그린다 — 반대편에 선을 그으면 '붙었다고 그려 놓고 안 붙은' 선이 된다"); + Assert.AreEqual(97, result.Guides[0].Position, 1e-9, "동률이면 좌표가 작은 쪽이 이긴다"); + } + + [TestMethod] + public void 중심_정합은_반정수를_보존한다() + { + var solver = Solver(new SnapRect(100, 0, 81, 20)); // CenterX = 140.5 + var result = solver.SolveMove(new SnapRect(0, 200, 40, 10), 120, 0, NoSpacing, free: false); + + Assert.IsTrue(result.SnappedX); + Assert.AreEqual(120.5, 0 + result.Dx, 1e-9, "반올림하면 중심이 0.5px 어긋난다"); + Assert.AreEqual(SnapGuideKind.SiblingCenter, result.Guides[0].Kind); + Assert.AreEqual(140.5, result.Guides[0].Position, 1e-9); + } + + [TestMethod] + public void 용지_가이드는_용지_전체로_긋는다() + { + var solver = Solver(); + var result = solver.SolveMove(new SnapRect(3, 200, 40, 10), 0, 0, NoSpacing, free: false); + + Assert.IsTrue(result.SnappedX); + Assert.AreEqual(SnapGuideKind.PageEdge, result.Guides[0].Kind); + Assert.AreEqual(0, result.Guides[0].Start, 1e-9); + Assert.AreEqual(856, result.Guides[0].End, 1e-9); + } + + [TestMethod] + public void 용지_중앙에_붙는다() + { + var solver = Solver(); + // 폭 40 이 용지 중앙(360)에 오려면 Left=340 + var result = solver.SolveMove(new SnapRect(337, 200, 40, 10), 0, 0, NoSpacing, free: false); + + Assert.IsTrue(result.SnappedX); + Assert.AreEqual(340, 337 + result.Dx, 1e-9); + Assert.AreEqual(SnapGuideKind.PageCenter, result.Guides[0].Kind); + Assert.AreEqual(360, result.Guides[0].Position, 1e-9); + } + + [TestMethod] + public void 후보가_없으면_격자로_떨어지고_가이드는_없다() + { + var solver = Solver(new SnapRect(500, 500, 20, 20)); + var result = solver.SolveMove(new SnapRect(101, 200, 40, 10), 0, 0, NoSpacing, free: false); + + Assert.IsFalse(result.SnappedX); + Assert.AreEqual(100, 101 + result.Dx, 1e-9); + Assert.AreEqual(0, result.Guides.Count); + } + + [TestMethod] + public void 형제_모서리가_용지_중앙보다_이긴다() + { + // 이동체 Left=337 → 형제 좌변 340 이 +3, 중심 357 → 용지 중앙 360 도 +3. + // 둘 다 실제로 맞으므로 선은 둘 다 그린다 — 갈리는 것은 '어느 쪽으로 보정하는가'다. + var solver = Solver(new SnapRect(340, 0, 200, 20)); + var result = solver.SolveMove(new SnapRect(337, 200, 40, 10), 0, 0, NoSpacing, free: false); + + Assert.AreEqual(340, 337 + result.Dx, 1e-9, "거리가 같으면 형제 모서리가 용지 중앙보다 이긴다"); + Assert.AreEqual(2, result.Guides.Count); + Assert.IsTrue(result.Guides.Any(g => g.Kind == SnapGuideKind.SiblingEdge)); + Assert.IsTrue(result.Guides.Any(g => g.Kind == SnapGuideKind.PageCenter)); + } + + [TestMethod] + public void 한_축만_붙어도_다른_축은_격자로_간다() + { + var solver = Solver(new SnapRect(100, 0, 50, 20)); + var result = solver.SolveMove(new SnapRect(97, 201, 40, 10), 0, 0, NoSpacing, free: false); + + Assert.IsTrue(result.SnappedX); + Assert.IsFalse(result.SnappedY); + Assert.AreEqual(200, 201 + result.Dy, 1e-9); + } + + [TestMethod] + public void Alt_는_격자까지_전부_끈다() + { + var solver = Solver(new SnapRect(100, 50, 80, 20)); + var result = solver.SolveMove(new SnapRect(0, 200, 40, 10), 97.3, 11.7, Options, free: true); + + Assert.AreEqual(97.3, result.Dx, 1e-9); + Assert.AreEqual(11.7, result.Dy, 1e-9); + Assert.IsFalse(result.SnappedX); + Assert.AreEqual(0, result.Guides.Count); + Assert.AreEqual(0, result.Spacings.Count); + } + + [TestMethod] + public void 같은_입력을_두_번_풀어도_결과가_같다() + { + var solver = Solver(new SnapRect(100, 0, 50, 20), new SnapRect(140, 400, 50, 20)); + var first = solver.SolveMove(new SnapRect(0, 200, 40, 10), 97, 0, Options, free: false); + var second = solver.SolveMove(new SnapRect(0, 200, 40, 10), 97, 0, Options, free: false); + + Assert.AreEqual(first.Dx, second.Dx, 1e-9); + Assert.AreEqual(first.Guides.Count, second.Guides.Count, "스크래치 버퍼가 새면 두 번째가 불어난다"); + Assert.AreEqual(first.Spacings.Count, second.Spacings.Count); + } + + [TestMethod] + public void 페이지가_멀리_떨어져_있어도_정밀도가_유지된다() + { + var solver = new SnapSolver(); + solver.Prepare(new SnapContext + { + Pages = new[] { new SnapRect(0, 10000, 720, 856) }, + Siblings = new[] { new SnapRect(100, 10050, 80, 20) }, + }); + var result = solver.SolveMove(new SnapRect(0, 10200, 40, 10), 97, 0, NoSpacing, free: false); + + Assert.AreEqual(100, 0 + result.Dx, 1e-9); + } + + // ── 간격 균등 ────────────────────────────────────────────────────── + + [TestMethod] + public void 두_형제_사이에_끼면_남는_틈을_반씩_나눈다() + { + // 틈 [50,200] = 150, 이동 폭 40 → 양쪽 55 씩 → Left = 105 + var solver = Solver(new SnapRect(0, 0, 50, 20), new SnapRect(200, 0, 50, 20)); + var result = solver.SolveMove(new SnapRect(103, 0, 40, 20), 0, 0, Options, free: false); + + Assert.IsTrue(result.SnappedX); + Assert.AreEqual(105, 103 + result.Dx, 1e-9); + Assert.AreEqual(2, result.Spacings.Count); + Assert.AreEqual(55, result.Spacings[0].Gap, 1e-9); + Assert.AreEqual(55, result.Spacings[1].Gap, 1e-9); + } + + [TestMethod] + public void 줄_뒤에_같은_간격으로_이어_붙는다() + { + // 간격 30 (50→80). 뒤에 붙으면 Left = 130 + 30 = 160 + var solver = Solver(new SnapRect(0, 0, 50, 20), new SnapRect(80, 0, 50, 20)); + var result = solver.SolveMove(new SnapRect(157, 0, 40, 20), 0, 0, Options, free: false); + + Assert.IsTrue(result.SnappedX); + Assert.AreEqual(160, 157 + result.Dx, 1e-9); + Assert.AreEqual(30, result.Spacings[^1].Gap, 1e-9); + } + + [TestMethod] + public void 줄_앞에_같은_간격으로_이어_붙는다() + { + // 간격 30 (150→180). 앞에 붙으면 Left = 100 − 30 − 40 = 30 + var solver = Solver(new SnapRect(100, 0, 50, 20), new SnapRect(180, 0, 50, 20)); + var result = solver.SolveMove(new SnapRect(33, 0, 40, 20), 0, 0, Options, free: false); + + Assert.IsTrue(result.SnappedX); + Assert.AreEqual(30, 33 + result.Dx, 1e-9); + } + + [TestMethod] + public void 교차축이_안_겹치면_같은_줄이_아니다() + { + var solver = Solver(new SnapRect(0, 500, 50, 20), new SnapRect(80, 500, 50, 20)); + var result = solver.SolveMove(new SnapRect(157, 0, 40, 20), 0, 0, Options, free: false); + + Assert.AreEqual(0, result.Spacings.Count); + } + + [TestMethod] + public void 형제가_하나면_간격_후보가_없다() + { + var solver = Solver(new SnapRect(0, 0, 50, 20)); + var result = solver.SolveMove(new SnapRect(300, 0, 40, 20), 0, 0, Options, free: false); + + Assert.AreEqual(0, result.Spacings.Count); + } + + [TestMethod] + public void 정렬이_되면_간격은_보지_않는다() + { + // 뒤에 붙는 자리(160)와 형제 좌변 정합(158)이 둘 다 사정권 + var solver = Solver(new SnapRect(0, 0, 50, 20), new SnapRect(80, 0, 50, 20), new SnapRect(158, 300, 20, 20)); + var result = solver.SolveMove(new SnapRect(157, 0, 40, 20), 0, 0, Options, free: false); + + Assert.IsTrue(result.SnappedX); + Assert.AreEqual(158, 157 + result.Dx, 1e-9, "정렬이 이긴다"); + Assert.AreEqual(0, result.Spacings.Count); + } + + [TestMethod] + public void 용지_밖으로_나가는_간격_자리는_버린다() + { + // 앞에 붙는 자리가 음수가 되는 배치 + var solver = Solver(new SnapRect(10, 0, 50, 20), new SnapRect(90, 0, 50, 20)); + var result = solver.SolveMove(new SnapRect(-58, 0, 40, 20), 0, 0, Options, free: false); + + Assert.AreEqual(0, result.Spacings.Count); + } + + [TestMethod] + public void 겹치는_형제가_너무_많으면_간격을_포기하고_정렬만_한다() + { + var many = new SnapRect[70]; + for (var i = 0; i < many.Length; i++) + { + many[i] = new SnapRect(i * 60, 0, 50, 20); + } + var solver = Solver(many); + var result = solver.SolveMove(new SnapRect(58, 0, 40, 20), 0, 0, Options, free: false); + + Assert.AreEqual(0, result.Spacings.Count, "성능 가드"); + Assert.IsTrue(result.SnappedX, "정렬 스냅은 그대로 돈다"); + } + + // ── 리사이즈 · 줌 ────────────────────────────────────────────────── + + [TestMethod] + public void 모서리_스냅은_첫_매치가_아니라_최근접이다() + { + var solver = Solver(new SnapRect(100, 0, 0, 20), new SnapRect(104, 0, 0, 20)); + var result = solver.SolveEdge(102.5, isXAxis: true, Options, free: false); + + Assert.IsTrue(result.Snapped); + Assert.AreEqual(104, result.Value, 1e-9, "이동 스냅과 같은 규칙이어야 한다"); + } + + [TestMethod] + public void 모서리_후보가_없으면_격자로_떨어진다() + { + var solver = Solver(new SnapRect(500, 0, 10, 20)); + var result = solver.SolveEdge(102, isXAxis: true, Options, free: false); + + Assert.IsFalse(result.Snapped); + Assert.AreEqual(104, result.Value, 1e-9); + } + + [TestMethod] + public void 모서리_스냅도_Alt_로_꺼진다() + { + var solver = Solver(new SnapRect(100, 0, 0, 20)); + var result = solver.SolveEdge(102.5, isXAxis: true, Options, free: true); + + Assert.IsFalse(result.Snapped); + Assert.AreEqual(102.5, result.Value, 1e-9); + } + + [TestMethod] + public void 허용오차는_화면_기준이라_줌에_반비례한다() + { + Assert.AreEqual(3, SnapOptions.ForZoom(6, 4, 2.0, true).Tolerance, 1e-9); + Assert.AreEqual(12, SnapOptions.ForZoom(6, 4, 0.5, true).Tolerance, 1e-9); + Assert.AreEqual(6, SnapOptions.ForZoom(6, 4, 1.0, true).Tolerance, 1e-9); + // 범위 밖 줌이 들어와도 오차가 폭주하지 않는다 + Assert.AreEqual(24, SnapOptions.ForZoom(6, 4, 0.01, true).Tolerance, 1e-9); + Assert.AreEqual(2, SnapOptions.ForZoom(6, 4, 99, true).Tolerance, 1e-9); + } + + [TestMethod] + public void 같은_거리라도_줌에_따라_붙고_안_붙는다() + { + var solver = Solver(new SnapRect(104, 0, 50, 20)); + var bbox = new SnapRect(100, 200, 40, 10); + + var zoomedIn = solver.SolveMove(bbox, 0, 0, SnapOptions.ForZoom(6, 4, 2.0, false), free: false); + Assert.IsFalse(zoomedIn.SnappedX, "줌 200% 에서 허용오차는 3 — 거리 4는 안 붙는다"); + + var zoomedOut = solver.SolveMove(bbox, 0, 0, SnapOptions.ForZoom(6, 4, 0.5, false), free: false); + Assert.IsTrue(zoomedOut.SnappedX, "줌 50% 에서 허용오차는 12 — 붙는다"); + } + #endregion +}