591 lines
18 KiB
C#
591 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using TechnologyAssembler.Core.IO;
|
|
|
|
namespace HashCalculator.GUI
|
|
{
|
|
internal abstract class NotifyPropertyChanged : INotifyPropertyChanged
|
|
{
|
|
#region INotifyPropertyChanged
|
|
public event PropertyChangedEventHandler? PropertyChanged;
|
|
|
|
protected void Notify(string name)
|
|
{
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
|
|
}
|
|
|
|
protected void SetField<X>(ref X field, X value, [CallerMemberName] string? propertyName = null)
|
|
{
|
|
if (propertyName == null)
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
|
|
if (EqualityComparer<X>.Default.Equals(field, value))
|
|
{
|
|
return;
|
|
}
|
|
|
|
field = value;
|
|
|
|
Notify(propertyName);
|
|
}
|
|
|
|
protected void SetField<X>(ref X field, X value, Action onChange, [CallerMemberName] string? propertyName = null)
|
|
{
|
|
if (propertyName == null)
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
|
|
if (EqualityComparer<X>.Default.Equals(field, value))
|
|
{
|
|
return;
|
|
}
|
|
|
|
field = value;
|
|
onChange();
|
|
Notify(propertyName);
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1812")]
|
|
internal class ViewModel : NotifyPropertyChanged
|
|
{
|
|
private static readonly Random _random = new();
|
|
public event EventHandler? ClearTracer;
|
|
public event EventHandler<ShowCopyableBoxEventArgs>? ShowCopyableBox;
|
|
public event EventHandler<OpenFileDialogEventArgs>? OpenFileDialog;
|
|
public MainInputViewModel MainInput { get; }
|
|
public BigInputViewModel BigEntryInput { get; }
|
|
|
|
private string? _filter;
|
|
public string? Filter
|
|
{
|
|
get => _filter;
|
|
set => SetField(ref _filter, value, () => FilterDisplayEntries.Execute(null));
|
|
}
|
|
|
|
private bool _gameObjectOnly;
|
|
public bool GameObjectOnly
|
|
{
|
|
get => _gameObjectOnly;
|
|
set => SetField(ref _gameObjectOnly, value, () => ConsiderTypeId &= !value);
|
|
}
|
|
|
|
private bool _considerTypeId;
|
|
public bool ConsiderTypeId
|
|
{
|
|
get => _considerTypeId;
|
|
set => SetField(ref _considerTypeId, value, () => GameObjectOnly &= !value);
|
|
}
|
|
|
|
public Command FilterDisplayEntries { get; }
|
|
|
|
private int _totalCount;
|
|
public int TotalCount
|
|
{
|
|
get => _totalCount;
|
|
set => SetField(ref _totalCount, value);
|
|
}
|
|
public ObservableSortedCollection<AssetEntry> DisplayEntries { get; } = new ObservableSortedCollection<AssetEntry>();
|
|
|
|
private string? _statusText;
|
|
public string StatusText
|
|
{
|
|
get => SuggestionString(_statusText);
|
|
set => SetField(ref _statusText, value);
|
|
}
|
|
|
|
private bool _isXml;
|
|
public bool IsXml
|
|
{
|
|
get => _isXml;
|
|
set => SetField(ref _isXml, value, () => IsXsd &= value);
|
|
}
|
|
private bool _isLoadingXml;
|
|
public bool IsLoadingXml
|
|
{
|
|
get => _isLoadingXml;
|
|
set => SetField(ref _isLoadingXml, value);
|
|
}
|
|
private bool _isXsd;
|
|
public bool IsXsd
|
|
{
|
|
get => _isXsd;
|
|
set => SetField(ref _isXsd, value, () =>
|
|
{
|
|
IsXml |= value;
|
|
ConsiderTypeId |= value;
|
|
});
|
|
}
|
|
public Command CancelXml { get; }
|
|
[SuppressMessage("Microsoft.Performance", "CA1822")]
|
|
public string LoadCsfText => $"{(Translator.HasProvider ? "更换" : "加载")} CSF";
|
|
public Command<MainWindow> LoadCsf { get; }
|
|
public Command ClearTraceText { get; }
|
|
|
|
public ViewModel()
|
|
{
|
|
var controller = new Controller(this);
|
|
MainInput = new MainInputViewModel(controller);
|
|
BigEntryInput = new BigInputViewModel(controller);
|
|
CancelXml = new Command(async () =>
|
|
{
|
|
try
|
|
{
|
|
CancelXml!.CanExecuteValue = false;
|
|
await controller.CancelLoadingXml().ConfigureAwait(true);
|
|
}
|
|
finally
|
|
{
|
|
CancelXml!.CanExecuteValue = true;
|
|
}
|
|
});
|
|
LoadCsf = new Command<MainWindow>(async window =>
|
|
{
|
|
try
|
|
{
|
|
LoadCsf!.CanExecuteValue = false;
|
|
var fileName = await controller.RequestOpenFile(string.Empty, ("*.csf;*.big", "CSF / BIG 文件"));
|
|
if (fileName is not null)
|
|
{
|
|
await controller.LoadCsf(fileName).ConfigureAwait(true);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
LoadCsf!.CanExecuteValue = true;
|
|
}
|
|
});
|
|
FilterDisplayEntries = new Command(() =>
|
|
{
|
|
controller.UpdateEntries();
|
|
return Task.CompletedTask;
|
|
});
|
|
ClearTraceText = new Command(() =>
|
|
{
|
|
ClearTracer?.Invoke(this, EventArgs.Empty);
|
|
return Task.CompletedTask;
|
|
});
|
|
}
|
|
|
|
public Task RequestCopyableBox(string title, Func<CancellationToken, Task<string>> getContent)
|
|
{
|
|
var data = new ShowCopyableBoxEventArgs(title, getContent);
|
|
ShowCopyableBox?.Invoke(this, data);
|
|
return data.Completion;
|
|
}
|
|
|
|
public Task<string?> RequestOpenFile(string title, IEnumerable<(string Extension, string? Description)> filters)
|
|
{
|
|
var data = new OpenFileDialogEventArgs(title, filters);
|
|
OpenFileDialog?.Invoke(this, data);
|
|
return data.Result;
|
|
}
|
|
|
|
public void NotifyCsfChange()
|
|
{
|
|
Notify(nameof(LoadCsfText));
|
|
FilterDisplayEntries.Execute(null);
|
|
}
|
|
|
|
public void AddNewItems(IEnumerable<AssetEntry> items)
|
|
{
|
|
DisplayEntries.SortedAddItems(items.Where(FilterDisplayEntry));
|
|
}
|
|
|
|
public void FilterCollection(HashSet<AssetEntry> orderedSource)
|
|
{
|
|
DisplayEntries.SortedRemoveItems(x => !orderedSource.Contains(x) || !FilterDisplayEntry(x));
|
|
DisplayEntries.SortedAddItems(orderedSource.Where(FilterDisplayEntry));
|
|
}
|
|
|
|
private bool FilterDisplayEntry(AssetEntry entry)
|
|
{
|
|
if (GameObjectOnly)
|
|
{
|
|
if (entry.Type != "GameObject")
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(Filter))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
foreach (var chunk in Filter!.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))
|
|
{
|
|
if (entry.NameString.Contains(chunk, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return true;
|
|
}
|
|
if (entry.InstanceIdString.Contains(chunk, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return true;
|
|
}
|
|
if (Translator.HasProvider)
|
|
{
|
|
if (entry.LocalizedNames.IndexOf(chunk, StringComparison.CurrentCultureIgnoreCase) != -1)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
if (!GameObjectOnly && ConsiderTypeId)
|
|
{
|
|
if (entry.TypeIdString.Contains(chunk, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private static string SuggestionString(string? text)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(text))
|
|
{
|
|
return text;
|
|
}
|
|
var generated = $"{_random.NextDouble()}";
|
|
System.Diagnostics.Debug.WriteLine(generated);
|
|
if (generated.Contains("38") || generated.Contains("16"))
|
|
{
|
|
return "你们都是喂鱼的马甲！（";
|
|
}
|
|
if (generated.IndexOf('2') == 2)
|
|
{
|
|
return "本来以为两小时就能写完这个小工具，没想到写了两个星期，开始怀疑自己的智商orz";
|
|
}
|
|
if (generated.IndexOf('7') < 5)
|
|
{
|
|
return "小提示：在下方的素材列表里，选择一行或多行之后，直接按 Ctrl+C 就可以复制内容~";
|
|
}
|
|
if (generated.IndexOf('2') == 3)
|
|
{
|
|
return "温馨提示：请多留意一下自己的重工，不要让它卖自己";
|
|
}
|
|
return "不知道该显示些什么呢……";
|
|
}
|
|
}
|
|
|
|
internal class InputBarViewModel : NotifyPropertyChanged
|
|
{
|
|
private IEnumerable<InputEntry>? _items;
|
|
public virtual IEnumerable<InputEntry>? Items
|
|
{
|
|
get => _items;
|
|
set => SetField(ref _items, value);
|
|
}
|
|
|
|
private InputEntry? _selectedItem;
|
|
public virtual InputEntry? SelectedItem
|
|
{
|
|
get => _selectedItem;
|
|
set => SetField(ref _selectedItem, value);
|
|
}
|
|
|
|
private int _selectedIndex;
|
|
public virtual int SelectedIndex
|
|
{
|
|
get => _selectedIndex;
|
|
set => SetField(ref _selectedIndex, value);
|
|
}
|
|
|
|
private string? _text;
|
|
public virtual string? Text
|
|
{
|
|
get => _text;
|
|
set => SetField(ref _text, value);
|
|
}
|
|
}
|
|
|
|
internal class MainInputViewModel : InputBarViewModel
|
|
{
|
|
private readonly FileSystemSuggestions _suggestions = new FileSystemSuggestions();
|
|
|
|
public override int SelectedIndex
|
|
{
|
|
get => base.SelectedIndex;
|
|
set
|
|
{
|
|
if (value == 0)
|
|
{
|
|
if (Items?.Count() <= 1)
|
|
{
|
|
value = -1;
|
|
}
|
|
else
|
|
{
|
|
value = base.SelectedIndex < value ? 1 : -1;
|
|
}
|
|
}
|
|
base.SelectedIndex = value;
|
|
}
|
|
}
|
|
|
|
public override string? Text
|
|
{
|
|
get => base.Text;
|
|
set
|
|
{
|
|
base.Text = value;
|
|
if (value != SelectedItem?.ToString())
|
|
{
|
|
UpdateList(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public Command<MainWindow> BrowseCommand { get; }
|
|
public Command<ViewModel> SelectCommand { get; }
|
|
|
|
public MainInputViewModel(Controller controller)
|
|
{
|
|
Items = Enumerable.Empty<InputEntry>();
|
|
BrowseCommand = new Command<MainWindow>(async window =>
|
|
{
|
|
var fileName = await controller.RequestOpenFile(string.Empty);
|
|
if (fileName is not null)
|
|
{
|
|
Text = fileName;
|
|
}
|
|
});
|
|
SelectCommand = new Command<ViewModel>(async viewModel =>
|
|
{
|
|
if (SelectedItem?.IsValid != true)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
BrowseCommand.CanExecuteValue = false;
|
|
SelectCommand!.CanExecuteValue = false;
|
|
await controller.OnMainInputDecided(SelectedItem).ConfigureAwait(true);
|
|
}
|
|
finally
|
|
{
|
|
BrowseCommand.CanExecuteValue = true;
|
|
SelectCommand!.CanExecuteValue = true;
|
|
SelectedIndex = -1;
|
|
}
|
|
});
|
|
}
|
|
|
|
private void UpdateList(string? path)
|
|
{
|
|
bool candidateFound = false;
|
|
var result = _suggestions.ProvideFileSystemSuggestions(path);
|
|
InputEntry? first = result.FirstOrDefault();
|
|
if (first != null)
|
|
{
|
|
if (new FileInfo(path!).FullName == new FileInfo(first.Value).FullName)
|
|
{
|
|
candidateFound = true;
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(path))
|
|
{
|
|
result = result.Prepend(new InputEntry(InputEntryType.Text, path!, path!));
|
|
}
|
|
Items = result;
|
|
|
|
if (candidateFound)
|
|
{
|
|
SelectedIndex = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class BigInputViewModel : InputBarViewModel
|
|
{
|
|
public override IEnumerable<InputEntry>? Items
|
|
{
|
|
get => base.Items;
|
|
set => base.Items = value;
|
|
}
|
|
|
|
public override InputEntry? SelectedItem
|
|
{
|
|
get => base.SelectedItem;
|
|
set
|
|
{
|
|
base.SelectedItem = value;
|
|
SelectCommand.CanExecuteValue = value != null;
|
|
}
|
|
}
|
|
|
|
public override string? Text
|
|
{
|
|
get => base.Text;
|
|
set
|
|
{
|
|
base.Text = value;
|
|
if (value != SelectedItem?.ToString())
|
|
{
|
|
if (AllManifests != null)
|
|
{
|
|
UpdateList(value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private InputEntry? _lastProcessedManifest;
|
|
public InputEntry? LastProcessedManifest
|
|
{
|
|
get => _lastProcessedManifest;
|
|
set => SetField(ref _lastProcessedManifest, value);
|
|
}
|
|
|
|
private IEnumerable<InputEntry>? _allManifests;
|
|
public IEnumerable<InputEntry>? AllManifests
|
|
{
|
|
get => _allManifests;
|
|
set
|
|
{
|
|
SetField(ref _allManifests, value);
|
|
Items = value;
|
|
SelectedItem = null;
|
|
LastProcessedManifest = null;
|
|
Text = null;
|
|
}
|
|
}
|
|
|
|
public Command<ViewModel> SelectCommand { get; }
|
|
|
|
public BigInputViewModel(Controller controller)
|
|
{
|
|
SelectCommand = new Command<ViewModel>(async viewModel =>
|
|
{
|
|
var mainInput = viewModel.MainInput;
|
|
try
|
|
{
|
|
SelectCommand!.CanExecuteValue = false;
|
|
mainInput.BrowseCommand.CanExecuteValue = false;
|
|
mainInput.SelectCommand.CanExecuteValue = false;
|
|
LastProcessedManifest = SelectedItem;
|
|
await controller.ProcessManifest(SelectedItem!.Value).ConfigureAwait(true);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
await viewModel.RequestCopyableBox("SAGE FastHash 计算器的错误", _ =>
|
|
{
|
|
return Task.FromResult($"在加载 manifest 时发生错误：{exception}");
|
|
});
|
|
}
|
|
finally
|
|
{
|
|
SelectCommand!.CanExecuteValue = true;
|
|
mainInput.BrowseCommand.CanExecuteValue = true;
|
|
mainInput.SelectCommand.CanExecuteValue = true;
|
|
}
|
|
})
|
|
{
|
|
CanExecuteValue = false
|
|
};
|
|
}
|
|
|
|
private void UpdateList(string? input)
|
|
{
|
|
input ??= string.Empty;
|
|
input = input.Replace(VirtualFileSystem.AltDirectorySeparatorChar, VirtualFileSystem.DirectorySeparatorChar);
|
|
|
|
var filtered = from manifest in AllManifests
|
|
where manifest.Value.IndexOf(input, StringComparison.OrdinalIgnoreCase) != -1
|
|
select manifest;
|
|
Items = filtered;
|
|
if (Items.FirstOrDefault()?.Value.Equals(input, StringComparison.OrdinalIgnoreCase) == true)
|
|
{
|
|
SelectedIndex = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class ObservableSortedCollection<T> : ObservableCollection<T> where T : IComparable<T>
|
|
{
|
|
private readonly HashSet<T> _set = new HashSet<T>();
|
|
|
|
public void SortedAddItems(IEnumerable<T> items)
|
|
{
|
|
try
|
|
{
|
|
items = from item in items
|
|
where !_set.Contains(item)
|
|
select item;
|
|
foreach (var item in items)
|
|
{
|
|
_set.Add(item);
|
|
base.Insert(BinarySearch(item), item);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
_set.Clear();
|
|
base.Clear();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public void SortedRemoveItems(Func<T, bool> ifRemove)
|
|
{
|
|
try
|
|
{
|
|
foreach (var i in Enumerable.Range(0, base.Count).Reverse())
|
|
{
|
|
var item = base[i];
|
|
if (ifRemove(item))
|
|
{
|
|
_set.Remove(item);
|
|
base.RemoveAt(i);
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
_set.Clear();
|
|
base.Clear();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private int BinarySearch(T entry)
|
|
{
|
|
var begin = 0;
|
|
var end = base.Count;
|
|
while (begin < end)
|
|
{
|
|
var middle = begin + (end - begin) / 2;
|
|
var result = entry.CompareTo(base[middle]);
|
|
if (result == 0)
|
|
{
|
|
return middle;
|
|
}
|
|
else if (result < 0)
|
|
{
|
|
end = middle;
|
|
}
|
|
else if (result > 0)
|
|
{
|
|
begin = middle + 1;
|
|
}
|
|
}
|
|
return end;
|
|
}
|
|
}
|
|
}
|