public SessionServiceViewModel(ISessionService sessionService,
IInputBoxService inputBoxService,
IMessageBoxService messageBoxService,
IWindowManager windowManager,
Lazy <IDocumentManager> documentManager,
ITextDocumentService textDocumentService,
IHistoryManager historyManager)
{
this.SessionService = sessionService;
this.inputBoxService = inputBoxService;
this.messageBoxService = messageBoxService;
this.windowManager = windowManager;
this.History = historyManager;
History.AddHandler(this);
Undo = new DelegateCommand(() => History.Undo(), () => History.CanUndo).ObservesProperty(() =>
History.CanUndo);
Redo = new DelegateCommand(() => History.Redo(), () => History.CanRedo).ObservesProperty(() =>
History.CanRedo);
NewSessionCommand = new AsyncAutoCommand(NewSession);
var save = new AsyncAutoCommand(SaveCurrent, _ => sessionService.IsNonEmpty);
SaveCurrentCurrent = save;
var forget = new AsyncAutoCommand(ForgetCurrent, _ => sessionService.IsOpened);
ForgetCurrentCurrent = forget;
DeleteItem = new DelegateCommand <ISolutionItem>(sessionService.RemoveItem, _ => sessionService.IsOpened).ObservesProperty(() => this.SessionService.IsOpened);
var preview = new DelegateCommand(() =>
{
var sql = sessionService.GenerateCurrentQuery();
if (sql == null)
{
return;
}
documentManager.Value.OpenDocument(textDocumentService.CreateDocument($"Preview of " + sessionService.CurrentSession !.Name, sql, "sql"));
}, () => sessionService.IsNonEmpty);
PreviewCurrentCommand = preview;
sessionService.ToObservable(o => o.IsNonEmpty)
.SubscribeAction(_ =>
{
preview.RaiseCanExecuteChanged();
forget.RaiseCanExecuteChanged();
save.RaiseCanExecuteChanged();
});
History.ToObservable(h => h.IsSaved)
.SubscribeAction(_ =>
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsModified)));
});
}
public PackageInitializerViewHandler(
[Import(typeof(SVsServiceProvider))]IServiceProvider serviceProvider,
IVsEditorAdaptersFactoryService adaptersFactoryService,
ITextDocumentService textDocumentService,
ITextDocumentFactoryService textDocumentFactoryService)
{
_serviceProvider = serviceProvider;
_adaptersFactoryService = adaptersFactoryService;
_textDocumentService = textDocumentService;
_textDocumentFactoryService = textDocumentFactoryService;
}
public PackageInitializerViewHandler(
[Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider,
IVsEditorAdaptersFactoryService adaptersFactoryService,
ITextDocumentService textDocumentService,
ITextDocumentFactoryService textDocumentFactoryService)
{
_serviceProvider = serviceProvider;
_adaptersFactoryService = adaptersFactoryService;
_textDocumentService = textDocumentService;
_textDocumentFactoryService = textDocumentFactoryService;
}
public HelpMenuItemProvider(IDocumentManager documentManager, IConfigureService settings,
Func <AboutViewModel> aboutViewModelCreator,
Func <DebugConsoleViewModel> debugConsole,
ITextDocumentService textDocumentService,
IReportBugService reportBugService,
IAnniversarySummaryService anniversarySummaryService)
{
DocumentManager = documentManager;
this.aboutViewModelCreator = aboutViewModelCreator;
this.debugConsole = debugConsole;
this.textDocumentService = textDocumentService;
this.anniversarySummaryService = anniversarySummaryService;
SubItems = new List <IMenuItem>();
SubItems.Add(new ModuleMenuItem("Report a bug", new DelegateCommand(reportBugService.ReportBug)));
SubItems.Add(new ModuleMenuItem("Send feedback", new DelegateCommand(reportBugService.SendFeedback)));
SubItems.Add(new ModuleManuSeparatorItem());
SubItems.Add(new ModuleMenuItem("Open debug console", new DelegateCommand(OpenDebugConsole)));
SubItems.Add(new ModuleMenuItem("Debug clear unused memory", new DelegateCommand(CallGC)));
SubItems.Add(new ModuleMenuItem("Open debug SQL console", new DelegateCommand(OpenDebugSqlConsole)));
SubItems.Add(new ModuleManuSeparatorItem());
SubItems.Add(new ModuleMenuItem("Open 2021 Summary", new DelegateCommand(anniversarySummaryService.OpenSummary)));
SubItems.Add(new ModuleMenuItem("About", new DelegateCommand(OpenAbout)));
}
public TextDocumentFactoryObserver(ITextDocumentFactoryService textDocumentFactoryService, ITextDocumentService textDocumentService)
{
_textDocumentFactoryService = textDocumentFactoryService;
_textDocumentService = textDocumentService;
}
public PacketDocumentViewModel(PacketDocumentSolutionItem solutionItem,
IMainThread mainThread,
MostRecentlySearchedService mostRecentlySearchedService,
IDatabaseProvider databaseProvider,
Func <INativeTextDocument> nativeTextDocumentCreator,
IMessageBoxService messageBoxService,
IPacketFilteringService filteringService,
IDocumentManager documentManager,
ITextDocumentService textDocumentService,
IWindowManager windowManager,
IPacketViewerSettings packetSettings,
IEnumerable <IPacketDumperProvider> dumperProviders,
IInputBoxService inputBoxService,
IHistoryManager history,
IPacketFilterDialogService filterDialogService,
IActionReactionProcessorCreator actionReactionProcessorCreator,
IRelatedPacketsFinder relatedPacketsFinder,
ITeachingTipService teachingTipService,
PacketDocumentSolutionNameProvider solutionNameProvider,
ISniffLoader sniffLoader,
ISpellStore spellStore,
PrettyFlagParameter prettyFlagParameter,
Func <IUpdateFieldsHistory> historyCreator)
{
this.solutionItem = solutionItem;
this.mainThread = mainThread;
this.messageBoxService = messageBoxService;
this.filteringService = filteringService;
this.actionReactionProcessorCreator = actionReactionProcessorCreator;
this.relatedPacketsFinder = relatedPacketsFinder;
this.sniffLoader = sniffLoader;
History = history;
history.LimitStack(20);
packetViewModelCreator = new PacketViewModelFactory(databaseProvider, spellStore);
MostRecentlySearched = mostRecentlySearchedService.MostRecentlySearched;
Title = solutionNameProvider.GetName(this.solutionItem);
SolutionItem = solutionItem;
FilterText = nativeTextDocumentCreator();
SelectedPacketPreview = nativeTextDocumentCreator();
SelectedPacketPreview.DisableUndo();
Watch(this, t => t.FilteringProgress, nameof(ProgressUnknown));
AutoDispose(history.AddHandler(new SelectedPacketHistory(this)));
filteredPackets = visiblePackets = AllPackets;
ApplyFilterCommand = new AsyncCommand(async() =>
{
if (inApplyFilterCommand)
{
return;
}
inApplyFilterCommand = true;
MostRecentlySearchedItem = FilterText.ToString();
inApplyFilterCommand = false;
if (!string.IsNullOrEmpty(FilterText.ToString()))
{
mostRecentlySearchedService.Add(FilterText.ToString());
}
if (currentActionToken != filteringToken)
{
throw new Exception("Invalid concurrent access!");
}
filteringToken?.Cancel();
filteringToken = null;
currentActionToken = null;
await FilterPackets(FilterText.ToString());
});
SaveToFileCommand = new AsyncCommand(async() =>
{
var path = await windowManager.ShowSaveFileDialog("Text file|txt");
if (path == null)
{
return;
}
LoadingInProgress = true;
FilteringInProgress = true;
try
{
await using StreamWriter writer = File.CreateText(path);
int i = 0;
int count = FilteredPackets.Count;
foreach (var packet in FilteredPackets)
{
await writer.WriteLineAsync(packet.Text);
if ((i % 100) == 0)
{
Report(i * 1.0f / count);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
await this.messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("Fatal error")
.SetMainInstruction("Fatal error during saving file")
.SetContent(e.Message)
.WithOkButton(false)
.Build());
}
LoadingInProgress = false;
FilteringInProgress = false;
});
OpenHelpCommand = new DelegateCommand(() => windowManager.OpenUrl("https://github.com/BAndysc/WoWDatabaseEditor/wiki/Packet-Viewer"));
On(() => SelectedPacket, doc =>
{
if (doc != null)
{
SelectedPacketPreview.FromString(doc.Text);
}
});
On(() => SplitUpdate, _ =>
{
SplitPacketsIfNeededAsync().Wait();
((ICommand)ApplyFilterCommand).Execute(null);
});
On(() => HidePlayerMove, _ =>
{
((ICommand)ApplyFilterCommand).Execute(null);
});
On(() => DisableFilters, _ =>
{
((ICommand)ApplyFilterCommand).Execute(null);
});
foreach (var dumper in dumperProviders)
{
Processors.Add(new(dumper));
}
QuickRunProcessor = new AsyncAutoCommand <ProcessorViewModel>(async(processor) =>
{
LoadingInProgress = true;
FilteringInProgress = true;
try
{
var tokenSource = new CancellationTokenSource();
AssertNoOnGoingTask();
currentActionToken = tokenSource;
var output = await RunProcessorsThreaded(new List <ProcessorViewModel>()
{
processor
}, tokenSource.Token).ConfigureAwait(true);
if (output != null && !tokenSource.IsCancellationRequested)
{
documentManager.OpenDocument(textDocumentService.CreateDocument($"{processor.Name} ({Title})", output, processor.Extension, true));
}
}
catch (Exception e)
{
Console.WriteLine(e);
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetIcon(MessageBoxIcon.Error)
.SetTitle("Fatal error")
.SetMainInstruction("Fatal error during processing")
.SetContent(
"Sorry, fatal error occured, this is probably a bug in processors, please report it in github\n\n" + e)
.WithOkButton(true)
.Build());
}
LoadingInProgress = false;
FilteringInProgress = false;
currentActionToken = null;
});
RunProcessors = new AsyncAutoCommand(async() =>
{
var processors = Processors.Where(s => s.IsChecked).ToList();
if (processors.Count == 0)
{
return;
}
LoadingInProgress = true;
FilteringInProgress = true;
try
{
var tokenSource = new CancellationTokenSource();
AssertNoOnGoingTask();
currentActionToken = tokenSource;
var output = await RunProcessorsThreaded(processors, tokenSource.Token).ConfigureAwait(true);
if (output != null && !tokenSource.IsCancellationRequested)
{
var extension = processors.Select(p => p.Extension).Distinct().Count() == 1
? processors[0].Extension
: "txt";
documentManager.OpenDocument(textDocumentService.CreateDocument($"{processors[0].Name} ({Title})", output, extension, true));
}
}
catch (Exception e)
{
Console.WriteLine(e);
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetIcon(MessageBoxIcon.Error)
.SetTitle("Fatal error")
.SetMainInstruction("Fatal error during processing")
.SetContent(
"Sorry, fatal error occured, this is probably a bug in processors, please report it in github\n\n" + e)
.WithOkButton(true)
.Build());
}
LoadingInProgress = false;
FilteringInProgress = false;
currentActionToken = null;
}, () => Processors.Any(c => c.IsChecked));
foreach (var proc in Processors)
{
AutoDispose(proc.ToObservable(p => p.IsChecked)
.SubscribeAction(_ => RunProcessors.RaiseCanExecuteChanged()));
}
UndoCommand = new DelegateCommand(history.Undo, () => history.CanUndo);
RedoCommand = new DelegateCommand(history.Redo, () => history.CanRedo);
History.PropertyChanged += (_, _) =>
{
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
};
IEnumerable <int> GetFindEnumerator(int start, int count, int direction, bool wrap)
{
for (int i = start + direction; i >= 0 && i < count; i += direction)
{
yield return(i);
}
if (wrap)
{
if (direction > 0)
{
for (int i = 0; i < start; ++i)
{
yield return(i);
}
}
else
{
for (int i = count - 1; i > start; --i)
{
yield return(i);
}
}
}
}
async Task Find(string searchText, int start, int direction)
{
var count = VisiblePackets.Count;
var searchToLower = searchText.ToLower();
foreach (var i in GetFindEnumerator(start, count, direction, true))
{
if (VisiblePackets[i].Text.Contains(searchToLower, StringComparison.InvariantCultureIgnoreCase))
{
SelectedPacket = VisiblePackets[i];
return;
}
}
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("Find")
.SetMainInstruction("Not found")
.SetContent("Cannot find text: " + searchText)
.WithOkButton(true)
.Build());
}
ToggleFindCommand = new DelegateCommand(() => FindPanelEnabled = !FindPanelEnabled);
CloseFindCommand = new DelegateCommand(() => FindPanelEnabled = false);
FindPreviousCommand = new AsyncAutoCommand <string>(async searchText =>
{
var start = SelectedPacket != null ? VisiblePackets.IndexOf(SelectedPacket) : 0;
await Find(searchText, start, -1);
}, str => str is string s && !string.IsNullOrEmpty(s));
FindNextCommand = new AsyncAutoCommand <string>(async searchText =>
{
var start = SelectedPacket != null ? VisiblePackets.IndexOf(SelectedPacket) : 0;
await Find(searchText, start, 1);
}, str => str is string s && !string.IsNullOrEmpty(s));
FindRelatedPacketsCommands = new AsyncAutoCommand(async() =>
{
if (selectedPacket == null)
{
return;
}
if (!await EnsureSplitOrDismiss())
{
return;
}
FilteringInProgress = true;
FilteringProgress = -1;
var tokenSource = new CancellationTokenSource();
AssertNoOnGoingTask();
currentActionToken = tokenSource;
IFilterData?newFilterData = await GetRelatedFilters(selectedPacket.Packet.BaseData.Number, tokenSource.Token);
FilteringInProgress = false;
currentActionToken = null;
if (newFilterData == null)
{
return;
}
if (!FilterData.IsEmpty)
{
if (await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("Find related packets")
.SetMainInstruction("Your current filter data is not empty")
.SetContent("Do you want to override current filter data?")
.WithButton("Override", true)
.WithButton("Merge", false)
.Build()))
{
FilterData = newFilterData;
}
else
{
FilterData.SetMinMax(Min(FilterData.MinPacketNumber, newFilterData.MinPacketNumber),
Max(FilterData.MaxPacketNumber, newFilterData.MaxPacketNumber));
if (newFilterData.IncludedGuids != null)
{
foreach (var guid in newFilterData.IncludedGuids)
{
FilterData.IncludeGuid(guid);
}
}
if (newFilterData.ForceIncludePacketNumbers != null)
{
foreach (var packet in newFilterData.ForceIncludePacketNumbers)
{
FilterData.IncludePacketNumber(packet);
}
}
}
}
else
{
FilterData = newFilterData;
}
await ApplyFilterCommand.ExecuteAsync();
});
ExcludeEntryCommand = new AsyncAutoCommand <PacketViewModel?>(async vm =>
{
if (vm == null || vm.Entry == 0)
{
return;
}
FilterData.ExcludeEntry(vm.Entry);
await ApplyFilterCommand.ExecuteAsync();
}, vm => vm is PacketViewModel pvm && pvm.Entry != 0);
IncludeEntryCommand = new AsyncAutoCommand <PacketViewModel?>(async vm =>
{
if (vm == null || vm.Entry == 0)
{
return;
}
FilterData.IncludeEntry(vm.Entry);
await ApplyFilterCommand.ExecuteAsync();
}, vm => vm is PacketViewModel pvm && pvm.Entry != 0);
ExcludeGuidCommand = new AsyncAutoCommand <PacketViewModel?>(async vm =>
{
if (vm == null || vm.MainActor == null)
{
return;
}
FilterData.ExcludeGuid(vm.MainActor);
await ApplyFilterCommand.ExecuteAsync();
}, vm => vm is PacketViewModel pvm && pvm.MainActor != null);
IncludeGuidCommand = new AsyncAutoCommand <PacketViewModel?>(async vm =>
{
if (vm == null || vm.MainActor == null)
{
return;
}
FilterData.IncludeGuid(vm.MainActor);
await ApplyFilterCommand.ExecuteAsync();
}, vm => vm is PacketViewModel pvm && pvm.MainActor != null);
ExcludeOpcodeCommand = new AsyncAutoCommand <PacketViewModel?>(async vm =>
{
if (vm == null)
{
return;
}
FilterData.ExcludeOpcode(vm.Opcode);
await ApplyFilterCommand.ExecuteAsync();
}, vm => vm != null);
IncludeOpcodeCommand = new AsyncAutoCommand <PacketViewModel?>(async vm =>
{
if (vm == null)
{
return;
}
FilterData.IncludeOpcode(vm.Opcode);
await ApplyFilterCommand.ExecuteAsync();
}, vm => vm != null);
AutoDispose(this.ToObservable(o => o.SelectedPacket).SubscribeAction(_ =>
{
ExcludeEntryCommand.RaiseCanExecuteChanged();
IncludeEntryCommand.RaiseCanExecuteChanged();
ExcludeGuidCommand.RaiseCanExecuteChanged();
IncludeGuidCommand.RaiseCanExecuteChanged();
ExcludeOpcodeCommand.RaiseCanExecuteChanged();
IncludeOpcodeCommand.RaiseCanExecuteChanged();
}));
ExplainSelectedPacketCommand = new AsyncAutoCommand(async() =>
{
if (!reasonPanelVisibility || actionReactionProcessor == null)
{
return;
}
if (selectedPacket == null)
{
return;
}
DetectedActions.Clear();
var detected = actionReactionProcessor.GetAllActions(selectedPacket.Id);
if (detected != null)
{
DetectedActions.AddRange(detected.Select(s => new DetectedActionViewModel(s)));
}
DetectedEvents.Clear();
var events = actionReactionProcessor.GetAllEvents(selectedPacket.Id);
if (events != null)
{
DetectedEvents.AddRange(events.Select(s => new DetectedEventViewModel(s)));
}
var reasons = actionReactionProcessor.GetPossibleEventsForAction(selectedPacket.Packet.BaseData);
Predictions.Clear();
foreach (var reason in reasons)
{
Predictions.Add(new ActionReasonPredictionViewModel(selectedPacket.Packet.BaseData, reason.rate.Value, reason.rate.Explain, reason.@event));
}
PossibleActions.Clear();
var actions = actionReactionProcessor.GetPossibleActionsForEvent(selectedPacket.Packet.BaseData.Number);
foreach (var action in actions)
{
var actionHappened = actionReactionProcessor.GetAction(action.packetId);
if (actionHappened == null)
{
continue;
}
PossibleActions.Add(new PossibleActionViewModel(selectedPacket.Packet.BaseData, action.chance, "", actionHappened.Value));
}
}, () => ReasonPanelVisibility);
On(() => ReasonPanelVisibility, isVisible =>
{
if (!isVisible)
{
return;
}
ApplyFilterCommand.ExecuteAsync().ContinueWith(_ =>
{
ExplainSelectedPacketCommand.Execute(null);
}, TaskContinuationOptions.NotOnCanceled | TaskContinuationOptions.NotOnFaulted).ListenErrors();
});
AutoDispose(this.ToObservable(o => o.SelectedPacket)
.CombineLatest(this.ToObservable(o => o.ReasonPanelVisibility))
.SubscribeAction(
_ =>
{
ExplainSelectedPacketCommand.Execute(null);
}));
OpenFilterDialogCommand = new AsyncAutoCommand(async() =>
{
var newData = await filterDialogService.OpenFilterDialog(FilterData);
if (newData != null)
{
FilterData = newData;
await ApplyFilterCommand.ExecuteAsync();
}
});
JumpToPacketCommand = new DelegateCommand <int?>(packetId =>
{
if (!packetId.HasValue)
{
return;
}
var packet = filteredPackets.FirstOrDefault(p => p.Id == packetId.Value);
if (packet != null)
{
SelectedPacket = packet;
}
});
GoToPacketCommand = new AsyncAutoCommand(async() =>
{
var min = filteredPackets[0].Id;
var max = filteredPackets[^ 1].Id;
public TextDocumentFactoryObserver(ITextDocumentFactoryService textDocumentFactoryService, ITextDocumentService textDocumentService)
{
_textDocumentFactoryService = textDocumentFactoryService;
_textDocumentService = textDocumentService;
}
public PacketDocumentViewModel(PacketDocumentSolutionItem solutionItem,
IMainThread mainThread,
MostRecentlySearchedService mostRecentlySearchedService,
IDatabaseProvider databaseProvider,
Func <INativeTextDocument> nativeTextDocumentCreator,
IMessageBoxService messageBoxService,
IPacketFilteringService filteringService,
IDocumentManager documentManager,
ITextDocumentService textDocumentService,
IWindowManager windowManager,
IPacketViewerSettings packetSettings,
IEnumerable <IPacketDumperProvider> dumperProviders,
ISniffLoader sniffLoader)
{
this.solutionItem = solutionItem;
this.mainThread = mainThread;
this.messageBoxService = messageBoxService;
this.filteringService = filteringService;
this.sniffLoader = sniffLoader;
packetViewModelCreator = new PacketViewModelFactory(databaseProvider);
MostRecentlySearched = mostRecentlySearchedService.MostRecentlySearched;
Title = "Sniff " + Path.GetFileNameWithoutExtension(solutionItem.File);
SolutionItem = solutionItem;
FilterText = nativeTextDocumentCreator();
SelectedPacketPreview = nativeTextDocumentCreator();
Watch(this, t => t.FilteringProgress, nameof(ProgressUnknown));
filteredPackets = AllPackets;
ApplyFilterCommand = new AsyncCommand(async() =>
{
if (inApplyFilterCommand)
{
return;
}
inApplyFilterCommand = true;
MostRecentlySearchedItem = FilterText.ToString();
inApplyFilterCommand = false;
if (!string.IsNullOrEmpty(FilterText.ToString()))
{
mostRecentlySearchedService.Add(FilterText.ToString());
}
if (currentActionToken != filteringToken)
{
throw new Exception("Invalid concurrent access!");
}
filteringToken?.Cancel();
filteringToken = null;
currentActionToken = null;
await FilterPackets(FilterText.ToString());
});
SaveToFileCommand = new AsyncCommand(async() =>
{
var path = await windowManager.ShowSaveFileDialog("Text file|txt");
if (path == null)
{
return;
}
LoadingInProgress = true;
FilteringInProgress = true;
try
{
await using StreamWriter writer = File.CreateText(path);
int i = 0;
int count = FilteredPackets.Count;
foreach (var packet in FilteredPackets)
{
await writer.WriteLineAsync(packet.Text);
if ((i % 100) == 0)
{
Report(i * 1.0f / count);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
await this.messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("Fatal error")
.SetMainInstruction("Fatal error during saving file")
.SetContent(e.Message)
.WithOkButton(false)
.Build());
}
LoadingInProgress = false;
FilteringInProgress = false;
});
OpenHelpCommand = new DelegateCommand(() => windowManager.OpenUrl("https://github.com/BAndysc/WoWDatabaseEditor/wiki/Packet-Viewer"));
On(() => SelectedPacket, doc =>
{
if (doc != null)
{
SelectedPacketPreview.FromString(doc.Text);
}
});
On(() => SplitUpdate, _ =>
{
SplitPacketsIfNeededAsync().Wait();
((ICommand)ApplyFilterCommand).Execute(null);
});
foreach (var dumper in dumperProviders)
{
Processors.Add(new(dumper));
}
RunProcessors = new AsyncAutoCommand(async() =>
{
var processors = Processors.Where(s => s.IsChecked).ToList();
if (processors.Count == 0)
{
return;
}
LoadingInProgress = true;
FilteringInProgress = true;
try
{
var tokenSource = new CancellationTokenSource();
AssertNoOnGoingTask();
currentActionToken = tokenSource;
var output = await RunProcessorsThreaded(processors, tokenSource.Token).ConfigureAwait(true);
if (!tokenSource.IsCancellationRequested)
{
var extension = processors.Select(p => p.Extension).Distinct().Count() == 1
? processors[0].Extension
: "txt";
documentManager.OpenDocument(textDocumentService.CreateDocument($"{processors[0].Name} ({Title})", output, extension));
}
}
catch (Exception e)
{
Console.WriteLine(e);
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetIcon(MessageBoxIcon.Error)
.SetTitle("Fatal error")
.SetMainInstruction("Fatal error during processing")
.SetContent(
"Sorry, fatal error occured, this is probably a bug in processors, please report it in github\n\n" + e)
.WithOkButton(true)
.Build());
}
LoadingInProgress = false;
FilteringInProgress = false;
currentActionToken = null;
}, _ => Processors.Any(c => c.IsChecked));
foreach (var proc in Processors)
{
AutoDispose(proc.ToObservable(p => p.IsChecked)
.SubscribeAction(_ => RunProcessors.RaiseCanExecuteChanged()));
}
wrapLines = packetSettings.Settings.WrapLines;
splitUpdate = packetSettings.Settings.AlwaysSplitUpdates;
if (!string.IsNullOrEmpty(packetSettings.Settings.DefaultFilter))
{
FilterText.FromString(packetSettings.Settings.DefaultFilter);
}
LoadSniff().ListenErrors();
AutoDispose(new ActionDisposable(() => currentActionToken?.Cancel()));
}