From a6d2180efa72fa549252abd6ac8d1b00fb57fd7c Mon Sep 17 00:00:00 2001
From: Snoozeds <88577069+Snoozeds@users.noreply.github.com>
Date: Tue, 16 Jul 2024 15:11:31 +0100
Subject: [PATCH] Add Find Replace menu

---
 src/UnrealLocresEditor/FindDialog.axaml.cs    |   2 -
 .../FindReplaceDialog.axaml                   |  32 ++
 .../FindReplaceDialog.axaml.cs                | 388 ++++++++++++++++++
 src/UnrealLocresEditor/Views/MainWindow.axaml |   3 +-
 .../Views/MainWindow.axaml.cs                 |  50 ++-
 5 files changed, 470 insertions(+), 5 deletions(-)
 create mode 100644 src/UnrealLocresEditor/FindReplaceDialog.axaml
 create mode 100644 src/UnrealLocresEditor/FindReplaceDialog.axaml.cs

diff --git a/src/UnrealLocresEditor/FindDialog.axaml.cs b/src/UnrealLocresEditor/FindDialog.axaml.cs
index 3a3b1f3..ef0533e 100644
--- a/src/UnrealLocresEditor/FindDialog.axaml.cs
+++ b/src/UnrealLocresEditor/FindDialog.axaml.cs
@@ -36,12 +36,10 @@ private void FindButton_Click(object sender, RoutedEventArgs e)
 
         private async void ScrollToSelectedRow(DataGrid dataGrid, int selectedRowIndex)
         {
-
             var row = MainWindow._rows[selectedRowIndex];
             var column = dataGrid.Columns[_currentMatchIndex];
             var columnplus = dataGrid.Columns[_currentMatchIndex + 1];
 
-
             // Fix bug where ScrollIntoView does not scroll the cell into view if the cell has a different height to other cells.
             // This is fucking stupid and it is 1AM.
 
diff --git a/src/UnrealLocresEditor/FindReplaceDialog.axaml b/src/UnrealLocresEditor/FindReplaceDialog.axaml
new file mode 100644
index 0000000..1c436e2
--- /dev/null
+++ b/src/UnrealLocresEditor/FindReplaceDialog.axaml
@@ -0,0 +1,32 @@
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        x:Class="UnrealLocresEditor.Views.FindReplaceDialog"
+        Title="Find and replace"
+        Width="350"
+        Height="225">
+
+	<Grid RowDefinitions="Auto,Auto,*,Auto,Auto,Auto,Auto" ColumnDefinitions="*,Auto" Margin="10">
+		<TextBox x:Name="uiSearchTextBox" Watermark="Find" Grid.Row="0" Grid.Column="0" Margin="0,0,5,0" />
+		<TextBox x:Name="uiReplaceTextBox" Watermark="Replace" Grid.Row="1" Grid.Column="0" Margin="0,10,5,0" />
+		<Button Name="uiFindButton" Content="Find" Grid.Row="0" Grid.Column="1" />
+		<TextBlock x:Name="uiMatchCountTextBlock" Grid.Row="2" Grid.ColumnSpan="2"
+                   HorizontalAlignment="Center" VerticalAlignment="Center" Text="" />
+		<StackPanel Orientation="Horizontal" Grid.Row="3" Grid.ColumnSpan="2" HorizontalAlignment="Center" Spacing="10" Margin="0,0,0,10">
+			<CheckBox x:Name="uiLocresModeCheckBox" Content="Locres mode" IsChecked="True" />
+			<Button Content="(?)" VerticalAlignment="Center" Margin="-10,0,0,0" Background="Transparent" BorderBrush="Transparent">
+				<ToolTip.Tip>
+					<ToolTip Content="Searches the 2nd column, then copies to the 3rd column and replaces the copied text." />
+				</ToolTip.Tip>
+			</Button>
+		</StackPanel>
+		<StackPanel Orientation="Horizontal" Grid.Row="4" Grid.ColumnSpan="2" HorizontalAlignment="Center" Spacing="10" Margin="0,0,0,10">
+			<Button x:Name="uiReplaceButton" Content="Replace" Width="100" />
+			<Button x:Name="uiReplaceAllButton" Content="Replace All" Width="100" />
+		</StackPanel>
+		<UniformGrid Grid.Row="6" Grid.ColumnSpan="2" Rows="1" Columns="3" Height="40">
+			<CheckBox x:Name="uiMatchCaseCheckBox" Content="Match case" />
+			<CheckBox x:Name="uiMatchWholeWordCheckBox" Content="Match whole word" />
+			<CheckBox x:Name="uiMatchCellCheckBox" Content="Match entire cell" />
+		</UniformGrid>
+	</Grid>
+</Window>
diff --git a/src/UnrealLocresEditor/FindReplaceDialog.axaml.cs b/src/UnrealLocresEditor/FindReplaceDialog.axaml.cs
new file mode 100644
index 0000000..48d8d5a
--- /dev/null
+++ b/src/UnrealLocresEditor/FindReplaceDialog.axaml.cs
@@ -0,0 +1,388 @@
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.Markup.Xaml;
+using Avalonia.Threading;
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace UnrealLocresEditor.Views
+{
+    public partial class FindReplaceDialog : Window
+    {
+        public FindReplaceDialog()
+        {
+            AvaloniaXamlLoader.Load(this);
+            this.Opened += OnWindowOpened;
+        }
+
+        private void OnWindowOpened(object? sender, EventArgs e)
+        {
+            InitializeComponent();
+
+            uiFindButton = this.FindControl<Button>("uiFindButton");
+            uiReplaceButton = this.FindControl<Button>("uiReplaceButton");
+            uiReplaceAllButton = this.FindControl<Button>("uiReplaceAllButton");
+            uiSearchTextBox = this.FindControl<TextBox>("uiSearchTextBox");
+            uiReplaceTextBox = this.FindControl<TextBox>("uiReplaceTextBox");
+
+            uiMatchCaseCheckBox = this.FindControl<CheckBox>("uiMatchCaseCheckBox");
+            uiMatchCellCheckBox = this.FindControl<CheckBox>("uiMatchCellCheckBox");
+            uiMatchWholeWordCheckBox = this.FindControl<CheckBox>("uiMatchWholeWordCheckBox");
+            uiLocresModeCheckBox = this.FindControl<CheckBox>("uiLocresModeCheckBox");
+
+            uiFindButton.Click += FindButton_Click;
+            uiReplaceButton.Click += ReplaceButton_Click;
+            uiReplaceAllButton.Click += ReplaceAllButton_Click;
+        }
+
+        public MainWindow? MainWindow { get; set; }
+        private int currentFindIndex = -1;
+        private int _currentRowIndex = -1;
+        private int _currentMatchIndex = -1;
+        private int _totalMatches = 0;
+        private string _lastSearchTerm = "";
+
+        private void FindButton_Click(object? sender, RoutedEventArgs e)
+        {
+            FindText(uiSearchTextBox.Text);
+        }
+
+        private async void ScrollToSelectedRow(DataGrid dataGrid, MainWindow.DataRow row)
+        {
+            if (_currentMatchIndex < 0 || _currentMatchIndex >= dataGrid.Columns.Count)
+            {
+                if (dataGrid.Columns.Count > 0)
+                {
+                    var fixedcolumn = dataGrid.Columns[0];
+                    dataGrid.ScrollIntoView(row, fixedcolumn);
+                }
+                return;
+            }
+
+            var column = dataGrid.Columns[_currentMatchIndex];
+            var columnplus = dataGrid.Columns[_currentMatchIndex + 1];
+
+            int jumpRowIndex = Math.Min(_currentRowIndex + 5, MainWindow._rows.Count - 1);
+            var jumpRow = MainWindow._rows[jumpRowIndex];
+
+            dataGrid.ScrollIntoView(jumpRow, columnplus);
+            dataGrid.ScrollIntoView(jumpRow, column);
+
+            await Task.Delay(1);
+
+            dataGrid.ScrollIntoView(row, columnplus);
+            dataGrid.ScrollIntoView(row, column);
+        }
+
+        public async void FindText(string searchTerm, bool forward = true)
+        {
+            if (string.IsNullOrEmpty(searchTerm)) return;
+
+            var dataGrid = MainWindow._dataGrid;
+            var items = MainWindow._rows;
+
+            if (items == null || dataGrid.Columns.Count == 0) return;
+
+            bool isMatchCaseChecked = uiMatchCaseCheckBox.IsChecked ?? false;
+            bool isMatchWholeWordChecked = uiMatchWholeWordCheckBox.IsChecked ?? false;
+            bool isMatchCellChecked = uiMatchCellCheckBox.IsChecked ?? false;
+
+            int increment = forward ? 1 : -1;
+            int startRowIndex = (_currentRowIndex + increment + items.Count) % items.Count;
+
+            StringComparison comparison = isMatchCaseChecked ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
+
+            for (int rowIndex = startRowIndex; ; rowIndex = (rowIndex + increment + items.Count) % items.Count)
+            {
+                var row = items[rowIndex];
+
+                for (int colIndex = (rowIndex == _currentRowIndex ? _currentMatchIndex + increment : (forward ? 0 : dataGrid.Columns.Count - 1));
+                     colIndex >= 0 && colIndex < dataGrid.Columns.Count;
+                     colIndex += increment)
+                {
+                    var column = dataGrid.Columns[colIndex];
+                    var cellContent = row.Values[colIndex];
+
+                    if (cellContent is string cellText)
+                    {
+                        if (isMatchCellChecked)
+                        {
+                            if (string.Equals(cellText, searchTerm, comparison))
+                            {
+                                _currentMatchIndex = colIndex;
+                                _currentRowIndex = rowIndex;
+                                var currentRow = items[_currentRowIndex];
+
+                                if (searchTerm != _lastSearchTerm)
+                                {
+                                    _currentMatchIndex = -1;
+                                    _currentRowIndex = -1;
+                                    _totalMatches = 0;
+                                    _lastSearchTerm = searchTerm;
+                                }
+
+                                else
+                                {
+                                    _totalMatches++;
+                                }
+
+                                await Dispatcher.UIThread.InvokeAsync(() =>
+                                {
+                                    dataGrid.InvalidateMeasure();
+                                    dataGrid.InvalidateArrange();
+
+                                    dataGrid.UpdateLayout();
+                                    dataGrid.SelectedItem = row;
+                                    dataGrid.Focus();
+
+                                    ScrollToSelectedRow(dataGrid, currentRow);
+                                }, DispatcherPriority.Background);
+
+                                return;
+                            }
+                        }
+                        else
+                        {
+                            if (isMatchWholeWordChecked)
+                            {
+                                if (IsWholeWordMatch(cellText, searchTerm, comparison))
+                                {
+                                    _currentMatchIndex = colIndex;
+                                    _currentRowIndex = rowIndex;
+                                    var currentRow = items[_currentRowIndex];
+
+                                    if (searchTerm != _lastSearchTerm)
+                                    {
+                                        _totalMatches = 1;
+                                        _lastSearchTerm = searchTerm;
+                                    }
+                                    else
+                                    {
+                                        _totalMatches++;
+                                    }
+
+                                    await Dispatcher.UIThread.InvokeAsync(() =>
+                                    {
+                                        dataGrid.InvalidateMeasure();
+                                        dataGrid.InvalidateArrange();
+
+                                        dataGrid.UpdateLayout();
+                                        dataGrid.SelectedItem = row;
+                                        dataGrid.Focus();
+
+                                        ScrollToSelectedRow(dataGrid, currentRow);
+                                    }, DispatcherPriority.Background);
+
+                                    return;
+                                }
+                            }
+                            else
+                            {
+                                if (cellText.IndexOf(searchTerm, comparison) >= 0)
+                                {
+                                    _currentMatchIndex = colIndex;
+                                    _currentRowIndex = rowIndex;
+                                    var currentRow = items[_currentRowIndex];
+
+                                    if (searchTerm != _lastSearchTerm)
+                                    {
+                                        _totalMatches = 1;
+                                        _lastSearchTerm = searchTerm;
+                                    }
+                                    else
+                                    {
+                                        _totalMatches++;
+                                    }
+
+                                    await Dispatcher.UIThread.InvokeAsync(() =>
+                                    {
+                                        dataGrid.InvalidateMeasure();
+                                        dataGrid.InvalidateArrange();
+
+                                        dataGrid.UpdateLayout();
+                                        dataGrid.SelectedItem = row;
+                                        dataGrid.Focus();
+
+                                        ScrollToSelectedRow(dataGrid, currentRow);
+                                    }, DispatcherPriority.Background);
+
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if (rowIndex == _currentRowIndex)
+                    break;
+            }
+
+            if (searchTerm != _lastSearchTerm)
+            {
+                _currentMatchIndex = -1;
+                _currentRowIndex = -1;
+                _totalMatches = 0;
+                _lastSearchTerm = searchTerm;
+            }
+        }
+
+        private bool IsWholeWordMatch(string cellValue, string searchText, StringComparison comparison)
+        {
+            string pattern = $@"\b{Regex.Escape(searchText)}\b";
+            var options = comparison == StringComparison.Ordinal ? RegexOptions.None : RegexOptions.IgnoreCase;
+            return Regex.IsMatch(cellValue, pattern, options);
+        }
+
+        private bool IsEntireCellMatch(string cellValue, string searchText, bool matchCase)
+        {
+            StringComparison comparison = matchCase ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
+            return string.Equals(cellValue, searchText, comparison);
+        }
+
+        private void ReplaceButton_Click(object? sender, RoutedEventArgs e)
+        {
+            if (MainWindow?._dataGrid?.SelectedItem != null)
+            {
+                var row = MainWindow._dataGrid.SelectedItem as MainWindow.DataRow;
+                if (row != null)
+                {
+                    var searchText = uiSearchTextBox.Text;
+                    var replaceText = uiReplaceTextBox.Text;
+                    bool matchCase = uiMatchCaseCheckBox.IsChecked == true;
+                    bool matchWholeWord = uiMatchWholeWordCheckBox.IsChecked == true;
+                    bool matchCell = uiMatchCellCheckBox.IsChecked == true;
+                    bool locresMode = uiLocresModeCheckBox.IsChecked == true;
+
+                    if (locresMode)
+                    {
+                        ReplaceTextInLocresMode(row, searchText, replaceText, matchCase, matchWholeWord, matchCell);
+                    }
+                    else
+                    {
+                        ReplaceTextInRow(row, searchText, replaceText, matchCase, matchWholeWord, matchCell);
+                    }
+                    MainWindow._dataGrid.ItemsSource = new ObservableCollection<MainWindow.DataRow>(MainWindow._dataGrid.ItemsSource.Cast<MainWindow.DataRow>().ToList());
+                    FindText(searchText, true);
+                }
+            }
+        }
+
+        private async void ReplaceAllButton_Click(object? sender, RoutedEventArgs e)
+        {
+            if (MainWindow?._dataGrid?.ItemsSource == null) return;
+
+            var searchText = uiSearchTextBox.Text;
+            var replaceText = uiReplaceTextBox.Text;
+            if (string.IsNullOrEmpty(searchText) || string.IsNullOrEmpty(replaceText)) return;
+
+            var items = MainWindow._dataGrid.ItemsSource.Cast<MainWindow.DataRow>().ToList();
+
+
+            bool matchCase = await Dispatcher.UIThread.InvokeAsync(() => uiMatchCaseCheckBox.IsChecked == true);
+            bool matchWholeWord = await Dispatcher.UIThread.InvokeAsync(() => uiMatchWholeWordCheckBox.IsChecked == true);
+            bool matchCell = await Dispatcher.UIThread.InvokeAsync(() => uiMatchCellCheckBox.IsChecked == true);
+            bool locresMode = await Dispatcher.UIThread.InvokeAsync(() => uiLocresModeCheckBox.IsChecked == true);
+
+            var tasks = items.Select(row => Task.Run(() =>
+            {
+                if (locresMode)
+                {
+                    ReplaceTextInLocresMode(row, searchText, replaceText, matchCase, matchWholeWord, matchCell);
+                }
+                else
+                {
+                    ReplaceTextInRow(row, searchText, replaceText, matchCase, matchWholeWord, matchCell);
+                }
+            })).ToArray();
+
+            await Task.WhenAll(tasks);
+
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                MainWindow._dataGrid.ItemsSource = new ObservableCollection<MainWindow.DataRow>(items);
+            });
+        }
+
+
+        private void ReplaceTextInRow(MainWindow.DataRow row, string searchText, string replaceText, bool matchCase, bool matchWholeWord, bool matchCell)
+        {
+            for (int i = 0; i < row.Values.Length; i++)
+            {
+                if (ShouldReplaceInCell(row.Values[i], searchText, matchCase, matchWholeWord, matchCell))
+                {
+                    row.Values[i] = row.Values[i].Replace(searchText, replaceText, StringComparison.OrdinalIgnoreCase);
+                }
+            }
+            row.OnPropertyChanged(nameof(row.Values));
+        }
+
+        private void ReplaceTextInLocresMode(MainWindow.DataRow row, string searchText, string replaceText, bool matchCase, bool matchWholeWord, bool matchCell)
+        {
+            if (ShouldReplaceInCell(row.Values[1], searchText, matchCase, matchWholeWord, matchCell))
+            {
+                row.Values[2] = row.Values[1].Replace(searchText, replaceText, StringComparison.OrdinalIgnoreCase);
+            }
+            row.OnPropertyChanged(nameof(row.Values));
+        }
+
+        private bool ShouldReplaceInCell(string cellValue, string searchText, bool matchCase, bool matchWholeWord, bool matchCell)
+        {
+            StringComparison comparison = matchCase ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
+
+            if (matchCase)
+            {
+                if (!cellValue.Contains(searchText, StringComparison.Ordinal))
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                if (!cellValue.Contains(searchText, StringComparison.OrdinalIgnoreCase))
+                {
+                    return false;
+                }
+            }
+
+            if (matchWholeWord)
+            {
+                if (!IsWholeWordMatch(cellValue, searchText, comparison))
+                {
+                    return false;
+                }
+            }
+
+            if (matchCell)
+            {
+                if (!IsEntireCellMatch(cellValue, searchText, matchCase))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+
+        private async Task ReplaceTextInRowAsync(MainWindow.DataRow row, string searchText, string replaceText, bool matchCase, bool matchWholeWord, bool matchCell)
+        {
+            for (int i = 0; i < row.Values.Length; i++)
+            {
+                if (ShouldReplaceInCell(row.Values[i], searchText, matchCase, matchWholeWord, matchCell))
+                {
+                    row.Values[i] = row.Values[i].Replace(searchText, replaceText, StringComparison.OrdinalIgnoreCase);
+                }
+            }
+
+            await Dispatcher.UIThread.InvokeAsync(() => row.OnPropertyChanged(nameof(row.Values)));
+        }
+
+        private void InitializeComponent()
+        {
+            AvaloniaXamlLoader.Load(this);
+        }
+    }
+}
diff --git a/src/UnrealLocresEditor/Views/MainWindow.axaml b/src/UnrealLocresEditor/Views/MainWindow.axaml
index db9f0d8..f4b619b 100644
--- a/src/UnrealLocresEditor/Views/MainWindow.axaml
+++ b/src/UnrealLocresEditor/Views/MainWindow.axaml
@@ -18,7 +18,8 @@
 				<MenuItem Header="Export locres" Name="uiSaveMenuItem"/>
 			</MenuItem>
 			<MenuItem Header="_Edit">
-				<MenuItem Header="Find" Name="uiFindMenuItem"/>
+				<MenuItem Header="Find" Name="uiFindMenuItem" InputGesture="Ctrl+F"/>
+				<MenuItem Header="Find and replace" Name="uiFindReplaceMenuItem" InputGesture="Ctrl+H"/>
 			</MenuItem>
 			<MenuItem Header="_Linux" Name="uiLinuxHeader">
 			<MenuItem Header="Attempt wine prefix" Name="uiWinePrefix"/>
diff --git a/src/UnrealLocresEditor/Views/MainWindow.axaml.cs b/src/UnrealLocresEditor/Views/MainWindow.axaml.cs
index 2fa7fb7..a9e84aa 100644
--- a/src/UnrealLocresEditor/Views/MainWindow.axaml.cs
+++ b/src/UnrealLocresEditor/Views/MainWindow.axaml.cs
@@ -402,6 +402,7 @@ private void LoadCsv(string csvFile)
         public class DataRow : INotifyPropertyChanged
         {
             private string[] _values;
+
             public string[] Values
             {
                 get => _values;
@@ -417,7 +418,7 @@ public string[] Values
 
             public event PropertyChangedEventHandler PropertyChanged;
 
-            protected void OnPropertyChanged(string propertyName)
+            public virtual void OnPropertyChanged(string propertyName)
             {
                 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
             }
@@ -512,6 +513,12 @@ private void InitializeComponent()
             var linuxMenuItem = this.FindControl<MenuItem>("uiLinuxHeader");
             linuxMenuItem.IsVisible = IsLinux();
 
+            var findMenuItem = this.FindControl<MenuItem>("uiFindMenuItem");
+            findMenuItem.Click += FindMenuItem_Click;
+
+            var findReplaceMenuItem = this.FindControl<MenuItem>("uiFindReplaceMenuItem");
+            findReplaceMenuItem.Click += FindReplaceMenuItem_Click;
+
             var winePrefixMenuItem = this.FindControl<MenuItem>("uiWinePrefix");
             winePrefixMenuItem.Click += WinePrefix_Click;
             winePrefixMenuItem.IsVisible = IsLinux();
@@ -535,7 +542,7 @@ private void InitializeComponent()
             {
                 uiDiscordActivityCheckBox.IsChecked = _appConfig.DiscordRPCEnabled;
             }
-            else if (_appConfig == null) 
+            else if (_appConfig == null)
             {
                 uiDiscordActivityCheckBox.IsChecked = true;
             }
@@ -543,6 +550,45 @@ private void InitializeComponent()
             DiscordRPCEnabled = uiDiscordActivityCheckBox.IsChecked ?? false;
         }
 
+        private FindDialog findDialog;
+        private void FindMenuItem_Click(object sender, RoutedEventArgs e)
+        {
+            if (findDialog == null)
+            {
+                findDialog = new FindDialog();
+                findDialog.Closed += FindDialog_Closed;
+                findDialog.MainWindow = this;
+            }
+
+            findDialog.Show();
+            findDialog.Activate();
+        }
+
+        private void FindDialog_Closed(object sender, EventArgs e)
+        {
+            findDialog = null;
+        }
+
+        private FindReplaceDialog findReplaceDialog;
+        private void FindReplaceMenuItem_Click(object sender, RoutedEventArgs e)
+        {
+            if (findReplaceDialog == null)
+            {
+                findReplaceDialog = new FindReplaceDialog();
+                findReplaceDialog.Closed += FindReplaceDialog_Closed;
+                findReplaceDialog.MainWindow = this;
+            }
+
+            findReplaceDialog.Show();
+            findReplaceDialog.Activate();
+        }
+
+        private void FindReplaceDialog_Closed(object sender, EventArgs e)
+        {
+            findReplaceDialog = null;
+        }
+
+
         private void DiscordRPC_Click(object sender, RoutedEventArgs e)
         {
             var checkBox = sender as CheckBox;