ksj09406
9a9c431b43
E-1. 원본 세 칸에 세로 스크롤 막대를 켰다. 가로와 달리 세로는 이 칸들이 실제로 굴러가므로 ScrollViewer 가 주는 막대를 그대로 쓴다. 대신 막대가 자리를 차지하는 만큼 여백 보정을 걷어냈다. 전에는 편집기 막대 폭만큼 오른쪽 여백을 줘서 글자 폭을 맞췄는데, 이제 진짜 막대가 그 자리를 차지하므로 여백까지 주면 글자 폭이 좁아져 접히는 자리가 어긋난다. E-2. 칸 폭을 줄였다 늘리면 행 높이가 돌아오지 않던 문제. 행 높이는 각 칸이 알려 온 글 높이 중 가장 큰 것을 쓴다. 그런데 글자를 그리는 칸이 세로로 늘어나 있어서(WPF 기본값 Stretch) 행이 한 번 커지면 그 다음부터는 "행 높이만큼 높다"고 되돌려 보냈다. 자기가 만든 값을 자기가 다시 읽는 셈이라 높이가 올라가기만 하고 내려오지 않았다. 글자 칸을 위로 붙여 자기 글 높이만 알리도록 고쳤다. E-3. 경로 줄과 코드 사이의 빈 공간. 패널 머리 높이를 상수로 못 박아 두어(124 / 74) 실제 내용보다 훨씬 컸다. 상수를 없애고 내용에 맞춰 줄어들게 한 뒤, 나란히 놓인 칸끼리는 SharedSizeGroup 으로 가장 큰 것에 맞춘다(REMOTE 만 Conflict 줄이 하나 더 있다). 2-Way 에서는 MERGED 머리도 같은 무리에 넣고 3-Way 에서는 뺀다. 2-Way 에서 한 화면에 보이는 코드가 29줄에서 34줄로 늘었다. 확인: 세로 막대를 끌면 세 칸이 함께 움직인다. 2560x1600 <-> 1920x1080 을 오가도, 가운데 구분선을 끌었다 되돌려도 처음과 같은 화면이 된다. 테스트 399건 그대로 통과. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1247 lines
58 KiB
C#
1247 lines
58 KiB
C#
using System;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Input;
|
|
using System.Windows.Interop;
|
|
using System.Windows.Media;
|
|
using System.Windows.Threading;
|
|
using MergeHub.Models;
|
|
using MergeHub.Services;
|
|
using UbisamBase.Core.Messaging;
|
|
using MergeHub.ViewModels;
|
|
|
|
namespace MergeHub.Views
|
|
{
|
|
/// <summary>
|
|
/// 홈 = 머지툴. DataContext(HomeViewModel)는 플랫폼 TabManager 가 DI 로 만들어 붙여준다.
|
|
///
|
|
/// LOCAL 패널은 세 겹이다 - 왼쪽 여백(줄 번호·[>]), 색과 문법을 그리는 표시층,
|
|
/// 그 위에 겹친 편집기. 세 겹이 같은 줄을 같은 눈높이에 보여줘야 하므로
|
|
/// 스크롤은 편집기가 주인이고 나머지가 따라간다.
|
|
/// </summary>
|
|
public partial class HomeView : UserControl
|
|
{
|
|
/// <summary>
|
|
/// 스크롤 맞추기가 진행 중인지. <b>한 번 켜지면 이번 일로 밀려서 오는 스크롤 이벤트가
|
|
/// 다 지나간 뒤에 풀린다.</b>
|
|
///
|
|
/// try/finally 로 곧바로 풀면 안 된다 - 목록(ListBox)의 ScrollChanged 는 배치가 끝난
|
|
/// <b>다음</b>에 오므로 그때는 이미 풀려 있고, 그 메아리가 다시 편집기를 굴린다.
|
|
/// 워드랩을 켜면 두 좌표계(편집기의 보이는 줄 ↔ 원본 칸의 행)의 환산이 딱 맞아떨어지지
|
|
/// 않아 그 메아리가 조금씩 어긋나고, 서로 밀어내다가 한 자리에 눌러앉는다 -
|
|
/// 3-Way 에서 워드랩을 켜면 세로 스크롤이 아예 안 되던 증상이 이것이다.
|
|
/// </summary>
|
|
private int _syncHold;
|
|
|
|
private bool Syncing => _syncHold > 0;
|
|
|
|
/// <summary>이번 스크롤 맞추기가 끝날 때까지 메아리를 막는다.</summary>
|
|
private void HoldSync()
|
|
{
|
|
_syncHold++;
|
|
|
|
// Input 은 배치(Render/Loaded)보다 늦게 돈다. 목록이 스크롤 이벤트를 다 뱉은 뒤에 풀린다.
|
|
Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
if (_syncHold > 0) _syncHold--;
|
|
}), DispatcherPriority.Input);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 아래층 글자를 가로로 미는 양. 편집기가 가로로 스크롤한 만큼 음수로 들어간다.
|
|
/// 여백(줄번호·[>])은 밀지 않고 글자만 밀어야 해서 이렇게 따로 둔다.
|
|
/// </summary>
|
|
public static readonly DependencyProperty TextShiftXProperty =
|
|
DependencyProperty.Register(nameof(TextShiftX), typeof(double), typeof(HomeView),
|
|
new PropertyMetadata(0.0));
|
|
|
|
public double TextShiftX
|
|
{
|
|
get => (double)GetValue(TextShiftXProperty);
|
|
set => SetValue(TextShiftXProperty, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 위쪽 원본 패널(BASE·REMOTE·LOCAL 원본)의 글자를 가로로 미는 양.
|
|
///
|
|
/// <see cref="TextShiftX"/> 와 따로 두는 이유 - 3-Way 에서는 위 세 칸과 아래 MERGED 의
|
|
/// <b>폭이 다르다</b>. 같은 값을 쓰면 넓은 MERGED 가 다 보여서 못 미는 만큼
|
|
/// 좁은 위 칸들도 못 밀어, 정작 잘려 보이는 쪽이 움직이지 않는다.
|
|
/// 2-Way 에서는 BASE 와 LOCAL 이 같은 폭이라 이 값이 <see cref="TextShiftX"/> 를 그대로 따라간다.
|
|
/// </summary>
|
|
public static readonly DependencyProperty SourceShiftXProperty =
|
|
DependencyProperty.Register(nameof(SourceShiftX), typeof(double), typeof(HomeView),
|
|
new PropertyMetadata(0.0, OnSourceShiftXChanged));
|
|
|
|
public double SourceShiftX
|
|
{
|
|
get => (double)GetValue(SourceShiftXProperty);
|
|
set => SetValue(SourceShiftXProperty, value);
|
|
}
|
|
|
|
/// <summary>편집기와 아래층이 똑같이 써야 하는 줄바꿈 방식.</summary>
|
|
public static readonly DependencyProperty WrapModeProperty =
|
|
DependencyProperty.Register(nameof(WrapMode), typeof(TextWrapping), typeof(HomeView),
|
|
new PropertyMetadata(TextWrapping.NoWrap));
|
|
|
|
public TextWrapping WrapMode
|
|
{
|
|
get => (TextWrapping)GetValue(WrapModeProperty);
|
|
set => SetValue(WrapModeProperty, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 위쪽 원본 세 칸의 가로 스크롤 설정.
|
|
///
|
|
/// 워드랩을 끄면 <c>Hidden</c> - 막대는 안 보이되 <b>굴릴 수 있는 상태여야</b>
|
|
/// 얼마나 더 갈 수 있는지(ExtentWidth)를 잴 수 있고, 그 값으로 <see cref="SourceShiftX"/> 를 묶는다.
|
|
/// 워드랩을 켜면 <c>Disabled</c> - 이래야 칸 너비가 정해져 글이 접힌다.
|
|
/// <c>Hidden</c> 인 채로 두면 너비가 무한으로 잡혀 <b>아무리 켜도 접히지 않는다.</b>
|
|
/// </summary>
|
|
public static readonly DependencyProperty SourceBarsProperty =
|
|
DependencyProperty.Register(nameof(SourceBars), typeof(ScrollBarVisibility), typeof(HomeView),
|
|
new PropertyMetadata(ScrollBarVisibility.Hidden));
|
|
|
|
public ScrollBarVisibility SourceBars
|
|
{
|
|
get => (ScrollBarVisibility)GetValue(SourceBarsProperty);
|
|
set => SetValue(SourceBarsProperty, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 원본 세 칸 아래에 붙는 <b>진짜</b> 가로 스크롤 막대의 값.
|
|
///
|
|
/// 왜 따로 두나 — 원본 칸은 ScrollViewer 를 가로로 굴리지 않는다(줄 번호까지 밀려 나가고
|
|
/// 세 칸이 어긋난다). 대신 글자만 <see cref="SourceShiftX"/> 로 민다. 그래서 ScrollViewer 가
|
|
/// 만들어 주는 막대는 <b>움직이지 않는 막대</b>가 되어 쓸 수 없다.
|
|
/// 막대를 따로 놓고 이 값과 <see cref="SourceShiftX"/> 를 서로 맞춘다.
|
|
/// </summary>
|
|
public static readonly DependencyProperty SourceScrollValueProperty =
|
|
DependencyProperty.Register(nameof(SourceScrollValue), typeof(double), typeof(HomeView),
|
|
new PropertyMetadata(0.0, OnSourceScrollValueChanged));
|
|
|
|
public double SourceScrollValue
|
|
{
|
|
get => (double)GetValue(SourceScrollValueProperty);
|
|
set => SetValue(SourceScrollValueProperty, value);
|
|
}
|
|
|
|
/// <summary>원본 칸에서 아직 못 보고 있는 가로 폭. 막대의 Maximum.</summary>
|
|
public static readonly DependencyProperty SourceScrollMaxProperty =
|
|
DependencyProperty.Register(nameof(SourceScrollMax), typeof(double), typeof(HomeView),
|
|
new PropertyMetadata(0.0));
|
|
|
|
public double SourceScrollMax
|
|
{
|
|
get => (double)GetValue(SourceScrollMaxProperty);
|
|
set => SetValue(SourceScrollMaxProperty, value);
|
|
}
|
|
|
|
/// <summary>지금 보이는 폭. 막대 손잡이의 크기를 정한다 - 없으면 손잡이가 점처럼 작아진다.</summary>
|
|
public static readonly DependencyProperty SourceViewportProperty =
|
|
DependencyProperty.Register(nameof(SourceViewport), typeof(double), typeof(HomeView),
|
|
new PropertyMetadata(0.0));
|
|
|
|
public double SourceViewport
|
|
{
|
|
get => (double)GetValue(SourceViewportProperty);
|
|
set => SetValue(SourceViewportProperty, value);
|
|
}
|
|
|
|
/// <summary>원본 칸 막대를 보일지. 3-Way 이고, 워드랩이 꺼져 있고, 실제로 밀 곳이 있을 때만.</summary>
|
|
public static readonly DependencyProperty SourceBarVisibilityProperty =
|
|
DependencyProperty.Register(nameof(SourceBarVisibility), typeof(Visibility), typeof(HomeView),
|
|
new PropertyMetadata(Visibility.Collapsed));
|
|
|
|
public Visibility SourceBarVisibility
|
|
{
|
|
get => (Visibility)GetValue(SourceBarVisibilityProperty);
|
|
set => SetValue(SourceBarVisibilityProperty, value);
|
|
}
|
|
|
|
/// <summary>막대와 <see cref="SourceShiftX"/> 가 서로를 다시 부르지 않게 막는다.</summary>
|
|
private bool _syncingSourceBar;
|
|
|
|
private static void OnSourceScrollValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
|
|
{
|
|
if (d is not HomeView view || view._syncingSourceBar) return;
|
|
|
|
view._syncingSourceBar = true;
|
|
try
|
|
{
|
|
view.SourceShiftX = -(double)e.NewValue;
|
|
}
|
|
finally
|
|
{
|
|
view._syncingSourceBar = false;
|
|
}
|
|
}
|
|
|
|
private static void OnSourceShiftXChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
|
|
{
|
|
if (d is not HomeView view || view._syncingSourceBar) return;
|
|
|
|
view._syncingSourceBar = true;
|
|
try
|
|
{
|
|
view.SourceScrollValue = -(double)e.NewValue;
|
|
}
|
|
finally
|
|
{
|
|
view._syncingSourceBar = false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 원본 칸 막대의 범위를 다시 잰다. 글이 바뀌거나 칸 폭이 달라지면 밀 수 있는 폭도 달라진다.
|
|
/// 지금 밀어 둔 값이 새 범위를 넘어서면 끝으로 당겨 둔다 - 안 그러면 빈 곳을 보게 된다.
|
|
/// </summary>
|
|
private void UpdateSourceScrollRange()
|
|
{
|
|
var threeWay = DataContext is HomeViewModel { IsThreeWay: true };
|
|
var room = threeWay && WrapMode == TextWrapping.NoWrap ? SourceScrollRoom() : 0;
|
|
|
|
SourceScrollMax = room;
|
|
SourceViewport = SourceViewportWidth();
|
|
SourceBarVisibility = room > 0.5 ? Visibility.Visible : Visibility.Collapsed;
|
|
|
|
if (-SourceShiftX > room) SourceShiftX = -room;
|
|
}
|
|
|
|
/// <summary>원본 칸에서 지금 보이는 폭.</summary>
|
|
private double SourceViewportWidth()
|
|
{
|
|
foreach (var pane in new[] { BaseLines, RemoteLines, OriginalLocalLines })
|
|
{
|
|
if (FindScrollViewer(pane) is { } viewer && viewer.ViewportWidth > 0) return viewer.ViewportWidth;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>워드랩을 켜면 가로 스크롤이 필요 없다.</summary>
|
|
public static readonly DependencyProperty HorizontalBarsProperty =
|
|
DependencyProperty.Register(nameof(HorizontalBars), typeof(ScrollBarVisibility), typeof(HomeView),
|
|
new PropertyMetadata(ScrollBarVisibility.Auto));
|
|
|
|
public ScrollBarVisibility HorizontalBars
|
|
{
|
|
get => (ScrollBarVisibility)GetValue(HorizontalBarsProperty);
|
|
set => SetValue(HorizontalBarsProperty, value);
|
|
}
|
|
|
|
/// <summary>ViewModel 이 글을 갈아 끼우는 중. 사용자의 편집과 구분하려고 둔다.</summary>
|
|
private bool _replacingText;
|
|
|
|
public HomeView()
|
|
{
|
|
InitializeComponent();
|
|
|
|
DataContextChanged += OnDataContextChanged;
|
|
|
|
// 설정 화면에서 비교 규칙을 고치고 돌아오면 그때 다시 비교한다.
|
|
IsVisibleChanged += (_, e) =>
|
|
{
|
|
if (e.NewValue is true && DataContext is HomeViewModel vm) vm.RecompareIfSettingsChanged();
|
|
};
|
|
// 두 패널은 같은 이동값을 쓴다. LOCAL 만 밀면 BASE 와 줄이 어긋나 보인다 -
|
|
// 나란히 놓고 보는 도구에서 이건 곧바로 눈에 띈다.
|
|
LocalLines.RenderTransform = _decorationShift;
|
|
BaseLines.RenderTransform = _decorationShift;
|
|
RemoteLines.RenderTransform = _decorationShift;
|
|
OriginalLocalLines.RenderTransform = _decorationShift;
|
|
|
|
foreach (var pane in new[] { LocalLines, BaseLines, RemoteLines, OriginalLocalLines })
|
|
BlockSelfScroll(pane);
|
|
|
|
LocalEditor.Loaded += (_, _) =>
|
|
{
|
|
HookEditorScroll();
|
|
MatchTextWidths();
|
|
};
|
|
|
|
// 글꼴·배율·창 크기가 바뀌면 다시 재서 맞춘다.
|
|
LayoutUpdated += (_, _) => AlignDecorationToEditor();
|
|
|
|
Loaded += (_, _) => HookHorizontalWheel();
|
|
Unloaded += (_, _) => UnhookHorizontalWheel();
|
|
}
|
|
|
|
// ================= 가로 휠 =================
|
|
|
|
private HwndSource? _wheelSource;
|
|
|
|
/// <summary>기울임 휠(가로 스크롤) 메시지. WPF 는 이 메시지를 라우팅해 주지 않는다.</summary>
|
|
private const int WM_MOUSEHWHEEL = 0x020E;
|
|
|
|
/// <summary>
|
|
/// 마우스 가로 휠을 직접 받아 코드 패널을 옆으로 굴린다.
|
|
///
|
|
/// WPF 에는 가로 휠 이벤트가 아예 없다 - <c>MouseWheel</c> 은 세로뿐이라, 창 메시지를
|
|
/// 직접 받아야 한다. 기울임 휠이 달린 마우스에서 "가로 휠이 안 먹는" 이유가 이것이다.
|
|
/// </summary>
|
|
private void HookHorizontalWheel()
|
|
{
|
|
if (_wheelSource is not null) return;
|
|
if (PresentationSource.FromVisual(this) is not HwndSource source) return;
|
|
|
|
_wheelSource = source;
|
|
source.AddHook(OnWindowMessage);
|
|
}
|
|
|
|
private void UnhookHorizontalWheel()
|
|
{
|
|
_wheelSource?.RemoveHook(OnWindowMessage);
|
|
_wheelSource = null;
|
|
}
|
|
|
|
private IntPtr OnWindowMessage(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
|
|
{
|
|
if (msg != WM_MOUSEHWHEEL) return IntPtr.Zero;
|
|
if (!IsVisible) return IntPtr.Zero;
|
|
|
|
// wParam 상위 16비트가 굴린 양이다. 오른쪽으로 굴리면 양수.
|
|
var delta = (short)((wParam.ToInt64() >> 16) & 0xFFFF);
|
|
if (delta == 0) return IntPtr.Zero;
|
|
|
|
// 세로 휠 한 칸이 세 줄인 것과 같은 감각으로 맞춘다.
|
|
const double StepPerNotch = 48;
|
|
var step = delta / 120.0 * StepPerNotch;
|
|
|
|
// 마우스가 놓인 칸을 민다. 3-Way 에서는 위 원본 세 칸과 아래 MERGED 의 폭이 달라
|
|
// 한 덩어리로 묶을 수 없다 - 가리키는 쪽이 움직이는 편이 손에 맞는다.
|
|
if (ScrollSourcePanes(step) || ScrollEditor(step)) handled = true;
|
|
|
|
return IntPtr.Zero;
|
|
}
|
|
|
|
/// <summary>MERGED(=2-Way 의 LOCAL) 편집기를 옆으로 굴린다. 아래층·BASE 는 스크롤 이벤트가 따라온다.</summary>
|
|
private bool ScrollEditor(double step)
|
|
{
|
|
if (FindScrollViewer(LocalEditor) is not { } viewer) return false;
|
|
if (viewer.ScrollableWidth <= 0) return false;
|
|
|
|
var offset = viewer.HorizontalOffset + step;
|
|
viewer.ScrollToHorizontalOffset(Math.Max(0, Math.Min(offset, viewer.ScrollableWidth)));
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 3-Way 의 위 원본 세 칸을 한꺼번에 민다. 셋은 폭도 행도 같으므로 늘 같이 움직여야 한다.
|
|
/// 마우스가 그 위에 있을 때만 잡는다.
|
|
/// </summary>
|
|
private bool ScrollSourcePanes(double step)
|
|
{
|
|
if (DataContext is not HomeViewModel { IsThreeWay: true }) return false;
|
|
if (!IsPointerOver(BaseLines) && !IsPointerOver(RemoteLines) && !IsPointerOver(OriginalLocalLines))
|
|
return false;
|
|
|
|
var room = SourceScrollRoom();
|
|
if (room <= 0) return false;
|
|
|
|
SourceShiftX = Math.Max(-room, Math.Min(0, SourceShiftX - step));
|
|
return true;
|
|
}
|
|
|
|
/// <summary>원본 칸에서 아직 못 보고 있는 가로 폭. 셋 중 가장 긴 줄을 기준으로 삼는다.</summary>
|
|
private double SourceScrollRoom()
|
|
{
|
|
var room = 0.0;
|
|
foreach (var pane in new[] { BaseLines, RemoteLines, OriginalLocalLines })
|
|
{
|
|
if (FindScrollViewer(pane) is not { } viewer) continue;
|
|
room = Math.Max(room, viewer.ExtentWidth - viewer.ViewportWidth);
|
|
}
|
|
return room;
|
|
}
|
|
|
|
private static bool IsPointerOver(FrameworkElement element)
|
|
{
|
|
if (!element.IsVisible || element.ActualWidth <= 0) return false;
|
|
|
|
var p = Mouse.GetPosition(element);
|
|
return p.X >= 0 && p.Y >= 0 && p.X <= element.ActualWidth && p.Y <= element.ActualHeight;
|
|
}
|
|
|
|
private void OnDataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
|
|
{
|
|
if (e.OldValue is HomeViewModel old)
|
|
{
|
|
old.EditorTextReplaced -= OnEditorTextReplaced;
|
|
old.ScrollToRowRequested -= OnScrollToRowRequested;
|
|
old.PropertyChanged -= OnViewModelPropertyChanged;
|
|
old.ReadEditorText = null;
|
|
}
|
|
|
|
if (e.NewValue is HomeViewModel now)
|
|
{
|
|
now.EditorTextReplaced += OnEditorTextReplaced;
|
|
now.ScrollToRowRequested += OnScrollToRowRequested;
|
|
now.PropertyChanged += OnViewModelPropertyChanged;
|
|
|
|
// 편집기 글은 이 컨트롤이 들고 있고, ViewModel 은 필요할 때만 읽어 간다.
|
|
// 바인딩으로 매 글자마다 문서 전체를 넘기면 큰 파일에서 눈에 띄게 느리다.
|
|
now.ReadEditorText = () => LocalEditor.Text;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 2-Way ↔ 3-Way 로 바뀌면 패널 배치가 통째로 달라진다.
|
|
/// 워드랩의 접히는 자리를 정하는 글자 폭 보정도 그때 다시 잡아야 한다.
|
|
/// </summary>
|
|
private void OnViewModelPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
|
|
{
|
|
if (e.PropertyName != nameof(HomeViewModel.IsThreeWay)) return;
|
|
|
|
// 배치가 통째로 달라지므로 원본 칸의 가로 위치는 처음으로 되돌린다.
|
|
SourceShiftX = 0;
|
|
|
|
// 열 폭이 실제로 다시 잡힌 뒤에 재야 한다.
|
|
Dispatcher.BeginInvoke(new Action(MatchTextWidths), DispatcherPriority.Loaded);
|
|
}
|
|
|
|
/// <summary>편집기 스크롤 감시를 이미 걸었는지. Loaded 는 탭을 오갈 때마다 다시 온다 -
|
|
/// 그때마다 또 걸면 스크롤 한 번에 맞추기가 두 번 돌아 메아리가 두 배가 된다.</summary>
|
|
private bool _editorScrollHooked;
|
|
|
|
/// <summary>
|
|
/// 편집기가 스크롤하면 나머지 두 겹과 BASE 패널을 같이 움직인다.
|
|
/// 편집기 안쪽 ScrollViewer 는 템플릿이 만들어 주므로 Loaded 이후에만 잡을 수 있다.
|
|
/// </summary>
|
|
private void HookEditorScroll()
|
|
{
|
|
if (_editorScrollHooked) return;
|
|
if (FindScrollViewer(LocalEditor) is not { } viewer) return;
|
|
|
|
_editorScrollHooked = true;
|
|
|
|
viewer.ScrollChanged += (_, e) =>
|
|
{
|
|
if (Syncing) return;
|
|
if (e.VerticalChange == 0 && e.HorizontalChange == 0) return;
|
|
|
|
HoldSync();
|
|
|
|
// 세로는 아래층·BASE·REMOTE 가 같이 굴러가고,
|
|
// 가로는 네 패널 모두 "글자만" 민다(TextShiftX) - 여백(줄번호·[>])은 제자리에 있어야 한다.
|
|
// 표시층 ListBox 를 가로로 굴리는 방법은 못 쓴다 - 행이 칸 너비에 맞춰 늘어나
|
|
// 굴릴 여지(ScrollableWidth)가 0 이라 아무 일도 일어나지 않는다.
|
|
Scroll(LocalLines, e.VerticalOffset, null);
|
|
ScrollSourcePanesTo(e.VerticalOffset);
|
|
TextShiftX = -e.HorizontalOffset;
|
|
|
|
// 2-Way 는 BASE 와 LOCAL 의 폭이 같으니 한 덩어리로 움직인다.
|
|
// 3-Way 의 위 세 칸은 폭이 달라 따로 움직이므로 여기서 건드리지 않는다.
|
|
if (DataContext is not HomeViewModel { IsThreeWay: true }) SourceShiftX = TextShiftX;
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// 나란히 놓인 패널들의 <b>글자 폭</b>을 똑같이 맞춘다.
|
|
///
|
|
/// 워드랩은 폭이 1px 만 달라도 접히는 자리가 달라져 행이 어긋난다.
|
|
/// 편집기에는 세로 스크롤 막대가 늘 붙어 있고 그 칸 오른쪽에는 미니맵이 있으므로,
|
|
/// 표시층에 그만큼 오른쪽 여백을 줘서 남는 폭을 같게 만든다.
|
|
///
|
|
/// 맞춰야 할 묶음이 모드마다 다르다.
|
|
/// 2-Way : BASE 와 LOCAL(편집기)이 나란히 있으므로 BASE 가 미니맵 폭까지 물러나야 한다.
|
|
/// 3-Way : 원본 세 칸이 서로 같은 폭이고 셋 다 미니맵이 없다. 여기서 BASE 만 미니맵
|
|
/// 폭을 빼면 <b>BASE 만 좁아져</b> 세 칸의 접히는 자리가 어긋난다.
|
|
/// 아래 MERGED 는 폭 자체가 달라 애초에 같이 맞출 수 없다(높이도 따로 센다).
|
|
/// </summary>
|
|
private void MatchTextWidths()
|
|
{
|
|
var bar = SystemParameters.VerticalScrollBarWidth;
|
|
var threeWay = (DataContext as HomeViewModel)?.IsThreeWay == true;
|
|
|
|
// 패널 머리(제목·경로)의 높이를 서로 맞춘다.
|
|
//
|
|
// 예전에는 상수로 못 박아 두었는데(124 / 74), 실제 내용보다 훨씬 커서
|
|
// <b>경로 줄과 코드 사이가 휑하게 비었다.</b> 이제 내용에 맞춰 줄어들고,
|
|
// 서로 다른 패널끼리는 SharedSizeGroup 이 가장 큰 것에 맞춰 준다
|
|
// (REMOTE 만 "Conflict N" 줄이 하나 더 있다).
|
|
//
|
|
// 2-Way 에서는 BASE 와 LOCAL(편집기 칸)이 나란히 있으므로 MERGED 머리도 같은 무리에 넣는다.
|
|
// 3-Way 에서는 MERGED 가 아래 줄로 내려가 맞출 상대가 없다 - 넣어 두면 그쪽 경로 줄 때문에
|
|
// 위 세 칸의 머리까지 덩달아 커진다.
|
|
MergedHeaderRow.SharedSizeGroup = threeWay ? null : "PaneHeader";
|
|
|
|
// 편집기 아래층은 편집기의 세로 막대만큼 물러난다 - 그 막대는 편집기가 그린다.
|
|
LocalLines.Margin = new Thickness(0, 0, bar, 0);
|
|
|
|
// 원본 세 칸은 <b>자기 세로 막대를 직접 그린다.</b> 그 막대가 이미 자리를 차지하므로
|
|
// 여백으로 또 물러나면 그만큼 글자 폭이 좁아져 접히는 자리가 어긋난다.
|
|
RemoteLines.Margin = new Thickness(0);
|
|
OriginalLocalLines.Margin = new Thickness(0);
|
|
|
|
// 2-Way 의 BASE 는 LOCAL 과 폭을 맞춰야 한다. LOCAL 쪽 칸에는 미니맵이 붙어 있으므로
|
|
// 그 폭만큼만 더 물러난다(막대 몫은 자기 막대가 이미 가져갔다).
|
|
BaseLines.Margin = threeWay
|
|
? new Thickness(0)
|
|
: new Thickness(0, 0, MiniMap.Width, 0);
|
|
|
|
// 칸 폭이 달라졌으니 원본 칸 막대의 범위도 다시 잰다.
|
|
ApplySourceScrollUnit();
|
|
UpdateSourceScrollRange();
|
|
}
|
|
|
|
/// <summary>표시층을 편집기 글자 위치에 맞추는 이동값. 아래 AlignDecorationToEditor 가 정한다.</summary>
|
|
private readonly TranslateTransform _decorationShift = new TranslateTransform();
|
|
|
|
/// <summary>
|
|
/// 표시층(색·문법)을 편집기가 알려 주는 글자 좌표에 맞춘다.
|
|
///
|
|
/// 두 층은 서로 다른 방식으로 글을 배치한다 - TextBox 는 자기 문서 레이아웃으로,
|
|
/// 아래층은 ListBox 행으로. 줄 간격은 같게 맞춰 놓았지만 <b>시작 위치가 일정하게 어긋난다</b>.
|
|
/// 상수로 보정하면 글꼴·배율이 바뀔 때마다 다시 틀리므로, 실제 좌표를 재서 맞춘다.
|
|
/// </summary>
|
|
private void AlignDecorationToEditor()
|
|
{
|
|
if (LocalEditor.Text.Length == 0) return;
|
|
|
|
// 반드시 <b>같은 줄끼리</b> 견줘야 한다.
|
|
//
|
|
// 예전에는 편집기의 0번 글자와 "처음 그려진 표시층 행"을 견줬는데, 목록이 가상화라
|
|
// 스크롤을 내리면 처음 그려진 행이 0행이 아니다. 그러면 "0번 글자(화면 위로 한참 올라간 자리)"와
|
|
// "화면 맨 위 행"을 비교하게 돼 이동값이 스크롤한 거리만큼 커지고, 표시층 글자가 통째로
|
|
// 위로 밀려 보인다 - 아래로 스크롤한 뒤 전체 되돌리기를 하면 실제로 그렇게 됐다.
|
|
if (FindFirst<ListBoxItem>(LocalLines) is not { } container) return;
|
|
if (FindFirst<Controls.CodeTextBlock>(container) is not { } sample) return;
|
|
|
|
var row = LocalLines.ItemContainerGenerator.IndexFromContainer(container);
|
|
if (row < 0) return;
|
|
|
|
var charIndex = CharacterIndexOfLine(LocalEditor.Text, row);
|
|
if (charIndex < 0) return;
|
|
|
|
try
|
|
{
|
|
var editorPoint = LocalEditor.TransformToVisual(this)
|
|
.Transform(LocalEditor.GetRectFromCharacterIndex(charIndex).TopLeft);
|
|
|
|
var decorationPoint = sample.TransformToVisual(this).Transform(new Point(0, 0));
|
|
|
|
// 두 좌표는 기준이 다르다. 실제로 재 보면(Consolas 12 · 줄 높이 20):
|
|
// GetRectFromCharacterIndex(0).Top = 4.67 → 줄상자 위 여백을 지난 "글자 상자" 위쪽
|
|
// CodeTextBlock 의 (0,0) = 0 → 여백을 포함한 "줄상자" 위쪽
|
|
// 이 여백(lead)을 빼지 않으면 표시층이 딱 그만큼 아래로 밀려서, 캐럿과 선택 영역이
|
|
// 글자보다 반 줄 위에 있는 것처럼 보인다. 여백은 글꼴에서 직접 구하므로
|
|
// 글자 크기나 화면 배율이 바뀌어도 따라간다.
|
|
var lead = sample.BaselineOffset - sample.FontFamily.Baseline * sample.FontSize;
|
|
if (double.IsNaN(lead) || double.IsInfinity(lead)) return;
|
|
|
|
// decorationPoint 는 지금 적용된 이동값이 이미 반영된 자리다.
|
|
// 그래서 "보정 없는 자리"로 되돌린 뒤 필요한 총 이동값을 구한다.
|
|
var wanted = editorPoint.Y - (decorationPoint.Y - _decorationShift.Y + lead);
|
|
|
|
// 이미 맞아 있으면 건드리지 않는다 - 매 프레임 흔들리는 것을 막는다.
|
|
if (Math.Abs(wanted - _decorationShift.Y) < 0.5) return;
|
|
|
|
// 가로는 건드리지 않는다. 여백(줄번호·[>])까지 밀려나기 때문이다 -
|
|
// 가로 스크롤은 글자에만 거는 TextShiftX 가 따로 맡는다.
|
|
_decorationShift.Y = wanted;
|
|
}
|
|
catch (InvalidOperationException)
|
|
{
|
|
// 아직 배치 전이면 좌표를 못 준다. 다음 기회에 다시 맞춘다.
|
|
}
|
|
}
|
|
|
|
private static T? FindFirst<T>(DependencyObject root) where T : DependencyObject
|
|
{
|
|
if (root is T hit) return hit;
|
|
|
|
var count = VisualTreeHelper.GetChildrenCount(root);
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
if (FindFirst<T>(VisualTreeHelper.GetChild(root, i)) is { } found) return found;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
// ================= 세로 스크롤 맞추기 =================
|
|
|
|
/// <summary>
|
|
/// 위쪽 원본 칸과 아래 MERGED 의 <b>행 높이가 다른</b> 상태.
|
|
///
|
|
/// 3-Way 에서 두 무리는 칸 너비가 다르므로, 워드랩을 켜면 접히는 자리가 달라
|
|
/// 같은 행이라도 높이가 달라진다. 이때는 픽셀을 그대로 넘겨서는 맞출 수 없다 -
|
|
/// 접힌 줄을 지날 때마다 조금씩 벌어져 결국 다른 줄을 보게 된다.
|
|
/// </summary>
|
|
private bool SourceRowsDifferFromEditor =>
|
|
WrapMode == TextWrapping.Wrap && DataContext is HomeViewModel { IsThreeWay: true };
|
|
|
|
/// <summary>코드 한 줄의 높이. XAML 의 CodeLineHeight 와 같은 값이어야 한다.</summary>
|
|
private double LineHeight =>
|
|
TryFindResource("CodeLineHeight") is double h && h > 0 ? h : 20;
|
|
|
|
/// <summary>원본 세 칸. 늘 함께 움직인다.</summary>
|
|
private ListBox[] SourcePanes => new[] { BaseLines, RemoteLines, OriginalLocalLines };
|
|
|
|
/// <summary>
|
|
/// 원본 칸을 <b>행 단위</b>로 굴릴지 <b>픽셀 단위</b>로 굴릴지 정한다.
|
|
///
|
|
/// 워드랩을 켠 3-Way 에서는 위 세 칸과 아래 MERGED 의 폭이 달라 같은 행이라도 접히는
|
|
/// 횟수가 다르다. 픽셀로 맞추려면 행마다 실제 높이를 알아야 하는데, 목록은 <b>가상화</b>라
|
|
/// 화면에 그려진 행만 자기 높이를 알려 준다. 아직 안 그려진 행은 기본값(한 줄)로 잡혀
|
|
/// 환산이 어긋나고, 그 어긋남이 되먹임으로 커져 스크롤이 한 자리에 눌러앉는다.
|
|
///
|
|
/// 그래서 이때는 <b>재지 않고 세는</b> 쪽으로 바꾼다. 행 단위로 굴리면 "몇 번째 행이
|
|
/// 맨 위인가"만 주고받으면 되므로 높이를 몰라도 정확히 맞는다.
|
|
/// 워드랩이 꺼져 있으면 모든 행이 같은 높이라 픽셀 그대로가 더 부드럽다.
|
|
/// </summary>
|
|
private void ApplySourceScrollUnit()
|
|
{
|
|
var unit = SourceRowsDifferFromEditor ? ScrollUnit.Item : ScrollUnit.Pixel;
|
|
|
|
foreach (var pane in SourcePanes)
|
|
{
|
|
if (VirtualizingPanel.GetScrollUnit(pane) != unit) VirtualizingPanel.SetScrollUnit(pane, unit);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 편집기 화면 <b>맨 위에 걸린 논리 행</b>. 좌표로 직접 물어본다.
|
|
///
|
|
/// 스크롤 값을 줄 높이로 나눠 세는 방법은 못 쓴다 - 실제로 재 보면 스크롤 160 일 때
|
|
/// 편집기가 말하는 첫 줄은 11 인데 화면 맨 위에 있는 것은 9행이었다. TextBox 의
|
|
/// 줄 번호 계산은 화면에 그려진 것과 딱 맞아떨어지지 않는다.
|
|
/// 그래서 "왼쪽 위 점에 있는 글자가 몇 행인가"를 물어본다 - 이건 그려진 대로 답한다.
|
|
/// </summary>
|
|
private int EditorTopRow()
|
|
{
|
|
var index = LocalEditor.GetCharacterIndexFromPoint(new Point(2, 2), snapToText: true);
|
|
if (index < 0) return 0;
|
|
|
|
var row = RowColumnAt(LocalEditor.Text, index).Row;
|
|
return row < 0 ? 0 : row;
|
|
}
|
|
|
|
/// <summary>그 논리 행이 편집기에서 시작하는 세로 위치(위의 역). 역시 좌표로 잰다.</summary>
|
|
private double EditorOffsetOfRow(int row)
|
|
{
|
|
if (FindScrollViewer(LocalEditor) is not { } viewer) return 0;
|
|
|
|
var start = CharacterIndexOfLine(LocalEditor.Text, row);
|
|
if (start < 0) return viewer.VerticalOffset;
|
|
|
|
try
|
|
{
|
|
// GetRectFromCharacterIndex 는 <b>보이는 영역 기준</b> 좌표를 준다.
|
|
// 지금 굴러가 있는 만큼을 더해야 문서 전체 기준이 된다.
|
|
var top = LocalEditor.GetRectFromCharacterIndex(start).Top;
|
|
if (double.IsNaN(top) || double.IsInfinity(top)) return viewer.VerticalOffset;
|
|
|
|
return Math.Max(0, viewer.VerticalOffset + top);
|
|
}
|
|
catch (ArgumentOutOfRangeException)
|
|
{
|
|
return viewer.VerticalOffset;
|
|
}
|
|
}
|
|
|
|
/// <summary>편집기가 굴러간 만큼 위쪽 원본 세 칸을 따라오게 한다.</summary>
|
|
private void ScrollSourcePanesTo(double editorOffset)
|
|
{
|
|
// 행 단위로 굴리는 중이면 오프셋의 뜻이 "픽셀"이 아니라 "몇 번째 행"이다.
|
|
var offset = SourceRowsDifferFromEditor ? EditorTopRow() : editorOffset;
|
|
|
|
foreach (var pane in SourcePanes) Scroll(pane, offset, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 표시층 ListBox 가 스스로 굴러가지 못하게 막는다.
|
|
///
|
|
/// ListBox 는 고른 줄이 화면 밖이면 알아서 굴려 보여 준다. 보통은 고마운 동작이지만
|
|
/// 여기서는 <b>스크롤 주인이 편집기 하나</b>여야 세 겹(여백·표시층·편집기)이 같은 줄을
|
|
/// 같은 눈높이에 놓는다. 특히 <b>가로</b>로 굴리면 줄 번호까지 화면 밖으로 밀려 나가고
|
|
/// 세 칸이 서로 어긋난다 — MERGED 에 긴 줄을 쓴 순간 원본 칸의 글이 통째로 사라지던 증상이 이것이다.
|
|
/// </summary>
|
|
private static void BlockSelfScroll(FrameworkElement pane) =>
|
|
pane.AddHandler(RequestBringIntoViewEvent,
|
|
new RequestBringIntoViewEventHandler((_, e) => e.Handled = true));
|
|
|
|
/// <summary>
|
|
/// 읽기 전용 패널(LOCAL 원본 · BASE · REMOTE)이 굴렀을 때.
|
|
///
|
|
/// <b>세로만</b> 받는다. 가로로는 이 칸들이 스스로 굴러서는 안 되는데,
|
|
/// ListBox 가 "고른 줄을 보이게" 하려고 선택이 바뀔 때마다 제멋대로 가로로 굴리기 때문이다
|
|
/// (MERGED 에 긴 줄을 쓰면 그 순간 세 칸의 글이 통째로 화면 밖으로 밀려났다).
|
|
/// 가로 이동은 <see cref="SourceShiftX"/> 한 곳으로만 한다 — 그래야 여백(줄 번호)이 제자리에 남는다.
|
|
/// </summary>
|
|
private void Lines_ScrollChanged(object sender, ScrollChangedEventArgs e)
|
|
{
|
|
if (sender is not ListBox source) return;
|
|
if (!ReferenceEquals(source, BaseLines) &&
|
|
!ReferenceEquals(source, RemoteLines) &&
|
|
!ReferenceEquals(source, OriginalLocalLines)) return;
|
|
|
|
// 저 혼자 가로로 굴렀으면 되돌려 놓는다. 스크롤 막대는 감춰 두었지만
|
|
// 굴릴 수 있는 상태여야 "얼마나 더 갈 수 있는지"(ExtentWidth)를 잴 수 있다.
|
|
if (e.HorizontalOffset != 0)
|
|
{
|
|
Scroll(source, null, 0);
|
|
return;
|
|
}
|
|
|
|
// 글이나 칸 폭이 바뀌면 밀 수 있는 폭도 달라진다. 스크롤 이벤트가 그때마다 온다.
|
|
if (e.ExtentWidthChange != 0 || e.ViewportWidthChange != 0) UpdateSourceScrollRange();
|
|
|
|
if (Syncing) return;
|
|
if (e.VerticalChange == 0) return;
|
|
|
|
HoldSync();
|
|
|
|
var editorOffset = SourceRowsDifferFromEditor
|
|
? EditorOffsetOfRow((int)Math.Round(e.VerticalOffset))
|
|
: e.VerticalOffset;
|
|
|
|
Scroll(LocalEditor, editorOffset, null);
|
|
Scroll(LocalLines, editorOffset, null);
|
|
|
|
foreach (var other in new[] { BaseLines, RemoteLines, OriginalLocalLines })
|
|
{
|
|
if (!ReferenceEquals(other, source)) Scroll(other, e.VerticalOffset, null);
|
|
}
|
|
}
|
|
|
|
private static void Scroll(DependencyObject target, double? vertical, double? horizontal)
|
|
{
|
|
if (FindScrollViewer(target) is not { } viewer) return;
|
|
|
|
if (vertical is { } v) viewer.ScrollToVerticalOffset(v);
|
|
if (horizontal is { } h) viewer.ScrollToHorizontalOffset(h);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 캐럿이 놓인 줄을 선택 줄로 삼는다. Accept / Revert 는 이 줄을 대상으로 한다.
|
|
/// 편집기 줄 번호와 화면 행 번호는 1:1 이다 - 지워진 줄 자리에 빈 줄(필러)을 넣어 뒀기 때문.
|
|
/// </summary>
|
|
private void LocalEditor_SelectionChanged(object sender, RoutedEventArgs e)
|
|
{
|
|
if (DataContext is not HomeViewModel vm) return;
|
|
|
|
// 행·열을 글에서 직접 센다.
|
|
//
|
|
// TextBox 의 GetLineIndexFromCharacterIndex / GetCharacterIndexFromLineIndex 는
|
|
// "화면에 보이는 줄" 기준이고, 글을 갈아 끼운 직후에는 CaretIndex 와 어긋난 값을 준다.
|
|
// 실제로 11글자짜리 줄에서 Home 을 눌렀는데 "10열"이 나오는 것을 확인했다.
|
|
var (row, column) = RowColumnAt(LocalEditor.Text, LocalEditor.CaretIndex);
|
|
vm.ReportCaret(row, column);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 글에서 캐럿 위치의 (행, 열)을 센다. 둘 다 0부터다.
|
|
/// 줄바꿈은 CRLF·LF 를 함께 다루고, CR 은 앞 줄의 끝이라 열에 세지 않는다.
|
|
/// </summary>
|
|
private static (int Row, int Column) RowColumnAt(string text, int caret)
|
|
{
|
|
if (caret < 0) caret = 0;
|
|
if (caret > text.Length) caret = text.Length;
|
|
|
|
var row = 0;
|
|
var lineStart = 0;
|
|
|
|
for (var i = 0; i < caret; i++)
|
|
{
|
|
if (text[i] != '\n') continue;
|
|
row++;
|
|
lineStart = i + 1;
|
|
}
|
|
|
|
var column = caret - lineStart;
|
|
|
|
// "...\r|\n" 처럼 CR 과 LF 사이에 캐럿이 있으면 그 줄의 끝으로 본다.
|
|
if (column > 0 && caret <= text.Length && caret > 0 && text[caret - 1] == '\r') column--;
|
|
|
|
return (row, Math.Max(0, column));
|
|
}
|
|
|
|
/// <summary>
|
|
/// 정렬이 바뀌어 편집기 글을 갈아 끼울 때, 캐럿이 맨 앞으로 튀지 않게 자리를 지킨다.
|
|
/// 글자 수 기준이라 완벽하지는 않지만, 타이핑 중 흐름이 끊기는 것은 막아 준다.
|
|
/// </summary>
|
|
private void OnEditorTextReplaced(object? sender, string text)
|
|
{
|
|
var caret = LocalEditor.CaretIndex;
|
|
|
|
// 글을 갈아 끼우면 TextChanged 가 도는데, 그걸 사용자의 편집으로 오해하면
|
|
// 다시 정렬이 끝없이 되풀이된다.
|
|
_replacingText = true;
|
|
try
|
|
{
|
|
LocalEditor.Text = text;
|
|
}
|
|
finally
|
|
{
|
|
_replacingText = false;
|
|
}
|
|
|
|
LocalEditor.CaretIndex = Math.Min(caret, text.Length);
|
|
}
|
|
|
|
/// <summary>사용자가 글자를 고쳤다. 무거운 일은 ViewModel 이 잠시 뒤에 한다.</summary>
|
|
private void LocalEditor_TextChanged(object sender, TextChangedEventArgs e)
|
|
{
|
|
if (_replacingText) return;
|
|
if (DataContext is HomeViewModel vm) vm.NotifyEditorEdited(LocalEditor.Text, LocalEditor.CaretIndex);
|
|
}
|
|
|
|
// ================= 차이 탐색 · 이동 · 북마크 =================
|
|
|
|
/// <summary>
|
|
/// 단축키. 어떤 키가 무슨 일을 하는지는 <see cref="ShortcutMap"/> 한 곳에만 적혀 있고
|
|
/// 설명 창도 같은 표를 읽는다 - 둘이 갈라지면 설명이 곧 거짓말이 된다.
|
|
///
|
|
/// 이 화면 전체(UserControl)의 <c>PreviewKeyDown</c> 에 걸어 둔다. 편집기에만 걸면
|
|
/// 파일 목록이나 찾기 칸에 초점이 있을 때 단축키가 죽고, 반대로 편집기가 먼저 삼키는
|
|
/// 키(Home/End)도 있어서다. 표에 없는 키는 손대지 않으므로 <c>Ctrl+A</c>·<c>Ctrl+Z</c> 같은
|
|
/// 편집 기본 동작은 그대로 편집기로 간다.
|
|
/// </summary>
|
|
private void View_PreviewKeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
// Alt 를 누르면 WPF 는 e.Key 에 Key.System 을 넣고 진짜 키는 e.SystemKey 로 보낸다.
|
|
var key = e.Key == Key.System ? e.SystemKey : e.Key;
|
|
|
|
if (ShortcutMap.Resolve(key, Keyboard.Modifiers) is not { } action) return;
|
|
if (RunShortcut(action)) e.Handled = true;
|
|
}
|
|
|
|
/// <summary>표가 고른 동작을 실제로 시킨다.</summary>
|
|
private bool RunShortcut(ShortcutAction action)
|
|
{
|
|
if (DataContext is not HomeViewModel vm) return false;
|
|
|
|
switch (action)
|
|
{
|
|
case ShortcutAction.NextDiff: return Run(vm.NextDiffCommand);
|
|
case ShortcutAction.PrevDiff: return Run(vm.PrevDiffCommand);
|
|
case ShortcutAction.FirstDiff: return Run(vm.FirstDiffCommand);
|
|
case ShortcutAction.LastDiff: return Run(vm.LastDiffCommand);
|
|
|
|
// 화살표는 WinMerge 와 같이 "어느 쪽으로 복사하는가"를 가리킨다.
|
|
// 2-Way 의 왼쪽은 BASE, 오른쪽은 편집 중인 내 칸.
|
|
// 3-Way 는 위에 LOCAL(Mine) · BASE · REMOTE(Theirs) 를 늘어놓고 결과는 아래 MERGED 하나뿐이라,
|
|
// "오른쪽으로" = 왼쪽 끝 LOCAL(Mine) 을 결과로, "왼쪽으로" = 오른쪽 끝 REMOTE(Theirs) 를 결과로 읽는다.
|
|
case ShortcutAction.CopyLeftToRight:
|
|
return Run(vm.IsThreeWay ? (ICommand)vm.AcceptLocalCommand : vm.AcceptCommand);
|
|
|
|
case ShortcutAction.CopyRightToLeft:
|
|
return Run(vm.IsThreeWay ? (ICommand)vm.AcceptRemoteCommand : vm.RevertCommand);
|
|
|
|
// 되돌릴 머지 작업이 없으면 키를 먹지 않는다 - 그래야 편집기의 글자 되돌리기가 살아 있다.
|
|
case ShortcutAction.Undo: return Run(vm.UndoCommand);
|
|
case ShortcutAction.Redo: return Run(vm.RedoCommand);
|
|
|
|
case ShortcutAction.Save:
|
|
return Run(vm.IsPlainMode ? (ICommand)vm.SavePlainCommand : vm.SaveAndCommitCommand);
|
|
|
|
case ShortcutAction.Recompare: return Run(vm.ReloadCommand);
|
|
|
|
case ShortcutAction.OpenFolderCompare:
|
|
UbisamBase.Core.Modules.TabManager.Activate(ViewIds.Folder);
|
|
return true;
|
|
|
|
case ShortcutAction.GoToLine:
|
|
GoToBox.Focus();
|
|
GoToBox.SelectAll();
|
|
return true;
|
|
|
|
case ShortcutAction.NextConflict: return Run(vm.NextConflictCommand);
|
|
case ShortcutAction.PrevConflict: return Run(vm.PrevConflictCommand);
|
|
case ShortcutAction.AutoMerge: return Run(vm.AutoMergeCommand);
|
|
|
|
case ShortcutAction.NextBookmark: return Run(vm.NextBookmarkCommand);
|
|
|
|
case ShortcutAction.ToggleBookmark:
|
|
if (vm.SelectedLine is null) return false;
|
|
vm.ToggleBookmarkCommand.Execute(vm.SelectedLine);
|
|
return true;
|
|
|
|
case ShortcutAction.AcceptBlock: return Run(vm.AcceptBlockCommand);
|
|
|
|
case ShortcutAction.Find: OpenFind(showReplace: false); return true;
|
|
case ShortcutAction.Replace: OpenFind(showReplace: true); return true;
|
|
case ShortcutAction.FindNext: FindStep(forward: true); return true;
|
|
case ShortcutAction.FindPrev: FindStep(forward: false); return true;
|
|
|
|
// 찾기 칸이 닫혀 있으면 Esc 는 손대지 않는다 - 다른 곳에서 쓸 자리를 뺏지 않기 위해서다.
|
|
case ShortcutAction.CloseFind:
|
|
if (FindBar.Visibility != Visibility.Visible) return false;
|
|
CloseFind();
|
|
return true;
|
|
|
|
case ShortcutAction.ShowHelp:
|
|
ShortcutHelpWindow.ShowOrActivate(Window.GetWindow(this));
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>지금 못 하는 동작(예: 고칠 게 없는데 저장)이면 키를 먹지 않고 넘긴다.</summary>
|
|
private static bool Run(ICommand command)
|
|
{
|
|
if (!command.CanExecute(null)) return false;
|
|
command.Execute(null);
|
|
return true;
|
|
}
|
|
|
|
private void ShortcutHelp_Click(object sender, RoutedEventArgs e) =>
|
|
ShortcutHelpWindow.ShowOrActivate(Window.GetWindow(this));
|
|
|
|
// ================= 찾기 =================
|
|
|
|
/// <summary>
|
|
/// 찾기 칸을 연다. 글자를 골라 둔 채로 눌렀으면 그 말을 그대로 채워 준다 -
|
|
/// 화면에서 눈에 띈 이름을 다시 타이핑하지 않게 하려는 것이다.
|
|
/// </summary>
|
|
private void OpenFind(bool showReplace)
|
|
{
|
|
FindBar.Visibility = Visibility.Visible;
|
|
ReplaceRow.Visibility = showReplace ? Visibility.Visible : Visibility.Collapsed;
|
|
|
|
var picked = LocalEditor.SelectedText;
|
|
if (!string.IsNullOrEmpty(picked) && !picked.Contains("\n")) FindBox.Text = picked;
|
|
|
|
if (showReplace) { ReplaceBox.Focus(); ReplaceBox.SelectAll(); }
|
|
else { FindBox.Focus(); FindBox.SelectAll(); }
|
|
}
|
|
|
|
private void CloseFind_Click(object sender, RoutedEventArgs e) => CloseFind();
|
|
|
|
private void CloseFind()
|
|
{
|
|
FindBar.Visibility = Visibility.Collapsed;
|
|
FindStatus.Text = string.Empty;
|
|
LocalEditor.Focus();
|
|
}
|
|
|
|
private void FindNext_Click(object sender, RoutedEventArgs e) => FindStep(forward: true);
|
|
private void FindPrev_Click(object sender, RoutedEventArgs e) => FindStep(forward: false);
|
|
|
|
/// <summary>
|
|
/// 지금 고른 자리를 바꾸고 다음으로 넘어간다.
|
|
///
|
|
/// 고른 자리가 찾는 말이 아니면 바꾸지 않고 <b>먼저 찾기만 한다</b> -
|
|
/// 엉뚱한 자리를 덮어쓰는 것보다 한 번 더 누르게 하는 편이 낫다.
|
|
/// </summary>
|
|
private void Replace_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var needle = FindBox.Text;
|
|
if (string.IsNullOrEmpty(needle)) return;
|
|
|
|
var how = FindMatchCase.IsChecked == true
|
|
? StringComparison.Ordinal
|
|
: StringComparison.OrdinalIgnoreCase;
|
|
|
|
if (LocalEditor.SelectionLength == needle.Length &&
|
|
string.Equals(LocalEditor.SelectedText, needle, how))
|
|
{
|
|
LocalEditor.SelectedText = ReplaceBox.Text;
|
|
}
|
|
|
|
FindStep(forward: true);
|
|
}
|
|
|
|
/// <summary>글 전체에서 한 번에 바꾼다. 되돌리기는 편집기의 Ctrl+Z 가 맡는다.</summary>
|
|
private void ReplaceAll_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var needle = FindBox.Text;
|
|
if (string.IsNullOrEmpty(needle)) return;
|
|
|
|
var how = FindMatchCase.IsChecked == true
|
|
? StringComparison.Ordinal
|
|
: StringComparison.OrdinalIgnoreCase;
|
|
|
|
var text = LocalEditor.Text;
|
|
var count = CountMatches(text, needle, how);
|
|
if (count == 0) { FindStatus.Text = "없음"; return; }
|
|
|
|
var caret = LocalEditor.CaretIndex;
|
|
LocalEditor.Text = ReplaceAll(text, needle, ReplaceBox.Text, how);
|
|
LocalEditor.CaretIndex = Math.Min(caret, LocalEditor.Text.Length);
|
|
|
|
FindStatus.Text = $"{count}개 바꿈";
|
|
MessageUtil.ShowSuccessToast($"{count}개를 바꿨습니다");
|
|
}
|
|
|
|
private static string ReplaceAll(string text, string needle, string with, StringComparison how)
|
|
{
|
|
var sb = new System.Text.StringBuilder(text.Length);
|
|
var at = 0;
|
|
|
|
while (true)
|
|
{
|
|
var next = text.IndexOf(needle, at, how);
|
|
if (next < 0) break;
|
|
|
|
sb.Append(text, at, next - at).Append(with);
|
|
at = next + needle.Length;
|
|
}
|
|
|
|
sb.Append(text, at, text.Length - at);
|
|
return sb.ToString();
|
|
}
|
|
|
|
|
|
/// <summary>찾기 칸에서 Enter 는 다음, Shift+Enter 는 이전, Esc 는 닫기.</summary>
|
|
private void FindBox_KeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
switch (e.Key)
|
|
{
|
|
case Key.Enter:
|
|
FindStep(forward: (Keyboard.Modifiers & ModifierKeys.Shift) == 0);
|
|
e.Handled = true;
|
|
break;
|
|
|
|
case Key.Escape:
|
|
CloseFind();
|
|
e.Handled = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// LOCAL 본문에서 찾은 자리를 골라 화면에 들인다.
|
|
/// 끝(또는 처음)까지 가면 반대쪽 끝으로 한 바퀴 돈다 - 차이 이동과 같은 감각이다.
|
|
/// </summary>
|
|
private void FindStep(bool forward)
|
|
{
|
|
var needle = FindBox.Text;
|
|
if (string.IsNullOrEmpty(needle))
|
|
{
|
|
OpenFind(showReplace: ReplaceRow.Visibility == Visibility.Visible);
|
|
return;
|
|
}
|
|
|
|
var hay = LocalEditor.Text;
|
|
if (hay.Length == 0) { FindStatus.Text = "없음"; return; }
|
|
|
|
var how = FindMatchCase.IsChecked == true
|
|
? StringComparison.Ordinal
|
|
: StringComparison.OrdinalIgnoreCase;
|
|
|
|
int found;
|
|
if (forward)
|
|
{
|
|
// 지금 고른 자리 바로 다음부터 - 안 그러면 같은 자리에 계속 머문다.
|
|
var from = LocalEditor.SelectionStart + (LocalEditor.SelectionLength > 0 ? 1 : 0);
|
|
if (from >= hay.Length) from = 0;
|
|
|
|
found = hay.IndexOf(needle, from, how);
|
|
if (found < 0) found = hay.IndexOf(needle, 0, how);
|
|
}
|
|
else
|
|
{
|
|
var upto = LocalEditor.SelectionStart - 1;
|
|
found = upto >= 0 ? hay.LastIndexOf(needle, Math.Min(upto, hay.Length - 1), how) : -1;
|
|
if (found < 0) found = hay.LastIndexOf(needle, hay.Length - 1, how);
|
|
}
|
|
|
|
if (found < 0)
|
|
{
|
|
FindStatus.Text = "없음";
|
|
return;
|
|
}
|
|
|
|
LocalEditor.Select(found, needle.Length);
|
|
BringCharIntoView(found);
|
|
|
|
FindStatus.Text = $"{CountMatches(hay, needle, how)}개";
|
|
}
|
|
|
|
private static int CountMatches(string hay, string needle, StringComparison how)
|
|
{
|
|
var count = 0;
|
|
for (var at = 0; at <= hay.Length - needle.Length;)
|
|
{
|
|
var next = hay.IndexOf(needle, at, how);
|
|
if (next < 0) break;
|
|
count++;
|
|
at = next + 1;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
/// <summary>이동 상자에서 Enter 를 치면 그 줄로 간다.</summary>
|
|
private void GoToBox_KeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
if (e.Key != Key.Enter) return;
|
|
if (DataContext is not HomeViewModel vm) return;
|
|
|
|
vm.GoToCommand.Execute(null);
|
|
LocalEditor.Focus();
|
|
e.Handled = true;
|
|
}
|
|
|
|
/// <summary>여백을 더블클릭하면 그 줄에 북마크를 켜고 끈다.</summary>
|
|
private void Gutter_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (e.ClickCount != 2) return;
|
|
if (DataContext is not HomeViewModel vm) return;
|
|
if (sender is not FrameworkElement element || element.DataContext is not MergeLine line) return;
|
|
|
|
vm.ToggleBookmarkCommand.Execute(line);
|
|
e.Handled = true;
|
|
}
|
|
|
|
private void ToggleReadOnly_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
if (DataContext is HomeViewModel vm) vm.IsReadOnly = !vm.IsReadOnly;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 워드랩을 켜고 끈다. 편집기와 아래층이 같은 규칙으로 접혀야 두 겹이 어긋나지 않는다.
|
|
/// 접을 때는 가로로 밀 일이 없으므로 밀어 둔 값도 되돌린다.
|
|
/// </summary>
|
|
private void ToggleWrap_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
if (DataContext is not HomeViewModel vm) return;
|
|
|
|
vm.WordWrap = !vm.WordWrap;
|
|
|
|
WrapMode = vm.WordWrap ? TextWrapping.Wrap : TextWrapping.NoWrap;
|
|
HorizontalBars = vm.WordWrap ? ScrollBarVisibility.Disabled : ScrollBarVisibility.Auto;
|
|
SourceBars = vm.WordWrap ? ScrollBarVisibility.Disabled : ScrollBarVisibility.Hidden;
|
|
|
|
if (vm.WordWrap)
|
|
{
|
|
TextShiftX = 0;
|
|
SourceShiftX = 0;
|
|
}
|
|
|
|
// 워드랩을 켜면 밀 곳이 없어지므로 막대도 사라져야 한다.
|
|
ApplySourceScrollUnit();
|
|
UpdateSourceScrollRange();
|
|
}
|
|
|
|
/// <summary>ViewModel 이 "이 행으로 가라"고 하면 캐럿과 스크롤을 함께 옮긴다.</summary>
|
|
/// <summary>
|
|
/// ViewModel 이 알려 준 <b>논리 행</b>으로 캐럿을 옮기고 그 자리가 보이게 굴린다.
|
|
///
|
|
/// TextBox 의 <c>GetCharacterIndexFromLineIndex</c> · <c>ScrollToLine</c> 은 모두
|
|
/// "화면에 보이는 줄" 기준이다. 워드랩이 켜지면 한 행이 여러 줄로 접히므로
|
|
/// 논리 행 번호를 그대로 넘기면 <b>다른 줄로 간다</b> - 실제로 "다음 차이"를 눌렀을 때
|
|
/// 상태바는 6행인데 화면에서 선택된 줄은 8행이었고, 아래로 갈수록 더 벌어졌다.
|
|
/// 그래서 논리 행 → 글자 위치로 직접 바꾼 뒤, 스크롤할 때만 다시 보이는 줄로 환산한다.
|
|
/// </summary>
|
|
private void OnScrollToRowRequested(object? sender, int row)
|
|
{
|
|
var start = CharacterIndexOfLine(LocalEditor.Text, row);
|
|
if (start < 0) return;
|
|
|
|
LocalEditor.CaretIndex = start;
|
|
LocalEditor.Focus();
|
|
|
|
// 배치가 끝난 뒤에 굴린다. 글을 갈아 끼운 직후에는 글자 좌표를 물어봐야
|
|
// 옛 정보가 나온다.
|
|
Dispatcher.BeginInvoke(new Action(BringCaretIntoView), DispatcherPriority.Loaded);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 캐럿이 있는 줄을 화면 위쪽에 여유를 두고 보이게 굴린다.
|
|
///
|
|
/// <c>TextBox.ScrollToLine</c> 을 쓰지 않는다 - 그 API 는 "화면에 보이는 줄" 번호를 받는데
|
|
/// 워드랩이 켜지면 논리 행과 어긋나고, 이 화면처럼 편집기가 세 겹의 스크롤 주인일 때는
|
|
/// 아예 굴러가지 않는 경우가 있었다(실제로 마지막 차이로 가도 화면이 맨 위에 남았다).
|
|
/// 대신 캐럿의 실제 좌표를 재서 스크롤뷰어를 그만큼 직접 옮긴다 - 워드랩이든 아니든 같다.
|
|
/// </summary>
|
|
private void BringCaretIntoView() => BringCharIntoView(LocalEditor.CaretIndex);
|
|
|
|
/// <summary>글 안의 어느 자리든 화면에 들여 놓는다(캐럿·찾은 자리 공통).</summary>
|
|
private void BringCharIntoView(int charIndex)
|
|
{
|
|
if (FindScrollViewer(LocalEditor) is not { } viewer) return;
|
|
|
|
Rect caret;
|
|
try
|
|
{
|
|
caret = LocalEditor.GetRectFromCharacterIndex(charIndex);
|
|
}
|
|
catch (InvalidOperationException)
|
|
{
|
|
return; // 아직 배치 전이면 좌표를 못 준다.
|
|
}
|
|
|
|
if (double.IsInfinity(caret.Top) || double.IsNaN(caret.Top)) return;
|
|
|
|
var margin = caret.Height > 0 ? caret.Height * 3 : 60;
|
|
var wanted = viewer.VerticalOffset + caret.Top - margin;
|
|
|
|
// 이미 화면 안 적당한 자리에 있으면 굳이 흔들지 않는다.
|
|
if (caret.Top >= margin && caret.Top + caret.Height <= viewer.ViewportHeight - margin) return;
|
|
|
|
viewer.ScrollToVerticalOffset(Math.Max(0, wanted));
|
|
}
|
|
|
|
/// <summary>논리 행(0부터)의 첫 글자 위치. 그런 행이 없으면 -1.</summary>
|
|
private static int CharacterIndexOfLine(string text, int row)
|
|
{
|
|
if (row < 0) return -1;
|
|
if (row == 0) return 0;
|
|
|
|
var line = 0;
|
|
|
|
for (var i = 0; i < text.Length; i++)
|
|
{
|
|
if (text[i] != '\n') continue;
|
|
|
|
line++;
|
|
if (line == row) return i + 1;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 각 패널의 글 높이를 행 모델에 알려 준다.
|
|
/// 두 패널이 서로의 높이를 알아야 워드랩에서 더 높은 쪽에 맞춰 행이 맞물린다.
|
|
/// </summary>
|
|
private static void ReportTextHeight(object sender, SizeChangedEventArgs e, MergeLine.TextPane pane)
|
|
{
|
|
if (sender is FrameworkElement element && element.DataContext is MergeLine line)
|
|
line.ReportTextHeight(pane, e.NewSize.Height);
|
|
}
|
|
|
|
private void BaseText_SizeChanged(object sender, SizeChangedEventArgs e) =>
|
|
ReportTextHeight(sender, e, MergeLine.TextPane.Base);
|
|
|
|
private void LocalText_SizeChanged(object sender, SizeChangedEventArgs e) =>
|
|
ReportTextHeight(sender, e, MergeLine.TextPane.Local);
|
|
|
|
private void RemoteText_SizeChanged(object sender, SizeChangedEventArgs e) =>
|
|
ReportTextHeight(sender, e, MergeLine.TextPane.Remote);
|
|
|
|
private void OriginalLocalText_SizeChanged(object sender, SizeChangedEventArgs e) =>
|
|
ReportTextHeight(sender, e, MergeLine.TextPane.OriginalLocal);
|
|
|
|
/// <summary>미니맵에서 찍은 위치의 줄로 세 겹을 함께 이동시킨다.</summary>
|
|
private void MiniMap_LineRequested(object sender, MergeLine line)
|
|
{
|
|
if (DataContext is not HomeViewModel vm) return;
|
|
|
|
vm.SelectedLine = line;
|
|
|
|
var index = vm.Lines.IndexOf(line);
|
|
if (index < 0) return;
|
|
|
|
// 스크롤 주인은 편집기 하나다. 표시층 ListBox 를 직접 굴리면 여백까지 밀려 나간다.
|
|
OnScrollToRowRequested(this, index);
|
|
}
|
|
|
|
private static ScrollViewer? FindScrollViewer(DependencyObject root)
|
|
{
|
|
if (root is ScrollViewer viewer) return viewer;
|
|
|
|
var count = VisualTreeHelper.GetChildrenCount(root);
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
var found = FindScrollViewer(VisualTreeHelper.GetChild(root, i));
|
|
if (found is not null) return found;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|