mirror of
https://github.com/MaSzyna-EU07/StarterNG.git
synced 2026-11-16 21:14:10 +01:00
Compare commits
6 Commits
feat/tapes
...
v1.6.302
| Author | SHA1 | Date | |
|---|---|---|---|
| c07ed2fb4d | |||
| cfea240243 | |||
|
|
2a85ca384a | ||
|
|
100bbea83e | ||
|
|
c370d1509e | ||
|
|
31fc4c3fdc |
65
StarterNG.Tests/FolderChangesTests.cs
Normal file
65
StarterNG.Tests/FolderChangesTests.cs
Normal file
@@ -0,0 +1,65 @@
|
||||
using StarterNG.Infrastructure.Adapters;
|
||||
|
||||
namespace StarterNG.Tests;
|
||||
|
||||
public sealed class FolderChangesTests : IDisposable
|
||||
{
|
||||
private static readonly TimeSpan Patience = TimeSpan.FromSeconds(10);
|
||||
private readonly string _root = Path.Combine(Path.GetTempPath(), "folder-changes-" + Guid.NewGuid().ToString("N"));
|
||||
|
||||
public FolderChangesTests() => Directory.CreateDirectory(Path.Combine(_root, "sub"));
|
||||
|
||||
public void Dispose() => Directory.Delete(_root, recursive: true);
|
||||
|
||||
private static async Task<bool> Reported(FolderChanges changes, Action change)
|
||||
{
|
||||
var told = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
||||
changes.Changed += () => told.TrySetResult();
|
||||
change();
|
||||
return await Task.WhenAny(told.Task, Task.Delay(Patience)) == told.Task;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_file_written_below_the_folder_is_reported()
|
||||
{
|
||||
string file = Path.Combine(_root, "sub", "a.scm");
|
||||
File.WriteAllText(file, "old");
|
||||
using var changes = new FolderChanges(_root);
|
||||
|
||||
Assert.True(changes.Watching);
|
||||
Assert.True(await Reported(changes, () => File.WriteAllText(file, "new text")));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_save_through_a_renamed_temp_file_is_reported()
|
||||
{
|
||||
string file = Path.Combine(_root, "test.scn");
|
||||
File.WriteAllText(file, "old");
|
||||
using var changes = new FolderChanges(_root);
|
||||
|
||||
Assert.True(await Reported(changes, () =>
|
||||
{
|
||||
string temp = file + ".tmp";
|
||||
File.WriteAllText(temp, "new");
|
||||
File.Move(temp, file, overwrite: true);
|
||||
}));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_file_removed_is_reported()
|
||||
{
|
||||
string file = Path.Combine(_root, "gone.scn");
|
||||
File.WriteAllText(file, "x");
|
||||
using var changes = new FolderChanges(_root);
|
||||
|
||||
Assert.True(await Reported(changes, () => File.Delete(file)));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_missing_folder_is_not_watched_and_does_not_throw()
|
||||
{
|
||||
using var changes = new FolderChanges(Path.Combine(_root, "nowhere"));
|
||||
|
||||
Assert.False(changes.Watching);
|
||||
}
|
||||
}
|
||||
192
StarterNG.Tests/FolderLooksTests.cs
Normal file
192
StarterNG.Tests/FolderLooksTests.cs
Normal file
@@ -0,0 +1,192 @@
|
||||
using Avalonia.Controls;
|
||||
using StarterNG.Infrastructure;
|
||||
|
||||
namespace StarterNG.Tests;
|
||||
|
||||
[Collection(AvaloniaControls.Name)]
|
||||
public sealed class FolderLooksTests : IDisposable
|
||||
{
|
||||
private static readonly TimeSpan Patience = TimeSpan.FromSeconds(10);
|
||||
private readonly string _root = Path.Combine(Path.GetTempPath(), "folder-looks-" + Guid.NewGuid().ToString("N"));
|
||||
private readonly ManualTime _time = new();
|
||||
private readonly Window _window;
|
||||
private int _looks;
|
||||
|
||||
public FolderLooksTests()
|
||||
{
|
||||
Directory.CreateDirectory(_root);
|
||||
HeadlessDrawing.Ensure();
|
||||
_window = new Window();
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_window.Close();
|
||||
Directory.Delete(_root, recursive: true);
|
||||
}
|
||||
|
||||
private FolderLooks Opened(string folder)
|
||||
{
|
||||
var looks = new FolderLooks(_window, () => folder, () =>
|
||||
{
|
||||
_looks++;
|
||||
return Task.CompletedTask;
|
||||
}, _time);
|
||||
_window.Show();
|
||||
Controls.Settle();
|
||||
_looks = 0;
|
||||
return looks;
|
||||
}
|
||||
|
||||
private ManualTimer Quiet => _time.Timers.Single(t => t.Period == Timeout.InfiniteTimeSpan);
|
||||
private ManualTimer Often => _time.Timers.Single(t => t.Period != Timeout.InfiniteTimeSpan);
|
||||
|
||||
// Waited for without leaving the thread: the window belongs to it.
|
||||
private static void Until(Func<bool> condition) => Assert.True(SpinWait.SpinUntil(condition, Patience), "waited too long");
|
||||
|
||||
[Fact]
|
||||
public void Nothing_is_watched_before_the_window_opens()
|
||||
{
|
||||
_ = new FolderLooks(_window, () => _root, () => Task.CompletedTask, _time);
|
||||
|
||||
Assert.Empty(_time.Timers);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_watched_folder_is_looked_at_anyway_seldom()
|
||||
{
|
||||
var looks = Opened(_root);
|
||||
|
||||
Assert.True(looks.Watching);
|
||||
Assert.Equal(FolderLooks.Watched, Often.Due);
|
||||
Assert.Equal(FolderLooks.Watched, Often.Period);
|
||||
Assert.Equal(Timeout.InfiniteTimeSpan, Quiet.Due);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_folder_the_system_reports_nothing_of_is_looked_at_often()
|
||||
{
|
||||
var looks = Opened(Path.Combine(_root, "nowhere"));
|
||||
|
||||
Assert.False(looks.Watching);
|
||||
Assert.Equal(FolderLooks.Unwatched, Often.Period);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_tick_looks_on_the_ui_thread_once_it_gets_there()
|
||||
{
|
||||
Opened(_root);
|
||||
|
||||
Often.Fire();
|
||||
Assert.Equal(0, _looks);
|
||||
Controls.Settle();
|
||||
|
||||
Assert.Equal(1, _looks);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_change_is_looked_at_once_the_reports_stop()
|
||||
{
|
||||
Opened(_root);
|
||||
|
||||
File.WriteAllText(Path.Combine(_root, "test.scn"), "new");
|
||||
Until(() => Quiet.Due == FolderLooks.Quiet);
|
||||
Controls.Settle();
|
||||
Assert.Equal(0, _looks);
|
||||
|
||||
Quiet.Fire();
|
||||
Controls.Settle();
|
||||
|
||||
Assert.Equal(1, _looks);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Coming_back_to_the_window_looks()
|
||||
{
|
||||
Opened(_root);
|
||||
|
||||
_window.Activate();
|
||||
Controls.Settle();
|
||||
|
||||
Assert.Equal(1, _looks);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Asked_it_looks()
|
||||
{
|
||||
var looks = Opened(_root);
|
||||
|
||||
Assert.True(looks.LookAsync().IsCompletedSuccessfully);
|
||||
|
||||
Assert.Equal(1, _looks);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Closed_it_stops_the_timers()
|
||||
{
|
||||
Opened(_root);
|
||||
|
||||
_window.Close();
|
||||
|
||||
Assert.Equal(2, _time.Timers.Count);
|
||||
Assert.All(_time.Timers, t => Assert.True(t.Disposed));
|
||||
}
|
||||
|
||||
private sealed class ManualTime : TimeProvider
|
||||
{
|
||||
private readonly List<ManualTimer> _timers = new();
|
||||
|
||||
public IReadOnlyList<ManualTimer> Timers
|
||||
{
|
||||
get
|
||||
{
|
||||
lock (_timers)
|
||||
return _timers.ToList();
|
||||
}
|
||||
}
|
||||
|
||||
public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
|
||||
{
|
||||
var timer = new ManualTimer(() => callback(state), dueTime, period);
|
||||
lock (_timers)
|
||||
_timers.Add(timer);
|
||||
return timer;
|
||||
}
|
||||
}
|
||||
|
||||
private sealed class ManualTimer : ITimer
|
||||
{
|
||||
private readonly Action _tick;
|
||||
private long _dueTicks;
|
||||
|
||||
public ManualTimer(Action tick, TimeSpan due, TimeSpan period)
|
||||
{
|
||||
_tick = tick;
|
||||
_dueTicks = due.Ticks;
|
||||
Period = period;
|
||||
}
|
||||
|
||||
public TimeSpan Due => TimeSpan.FromTicks(Interlocked.Read(ref _dueTicks));
|
||||
public TimeSpan Period { get; private set; }
|
||||
public bool Disposed { get; private set; }
|
||||
|
||||
public void Fire() => _tick();
|
||||
|
||||
public bool Change(TimeSpan dueTime, TimeSpan period)
|
||||
{
|
||||
if (Disposed)
|
||||
throw new ObjectDisposedException(nameof(ManualTimer));
|
||||
Interlocked.Exchange(ref _dueTicks, dueTime.Ticks);
|
||||
Period = period;
|
||||
return true;
|
||||
}
|
||||
|
||||
public void Dispose() => Disposed = true;
|
||||
|
||||
public ValueTask DisposeAsync()
|
||||
{
|
||||
Dispose();
|
||||
return ValueTask.CompletedTask;
|
||||
}
|
||||
}
|
||||
}
|
||||
80
StarterNG.Tests/OneAtATimeTests.cs
Normal file
80
StarterNG.Tests/OneAtATimeTests.cs
Normal file
@@ -0,0 +1,80 @@
|
||||
using StarterNG.Application;
|
||||
|
||||
namespace StarterNG.Tests;
|
||||
|
||||
public class OneAtATimeTests
|
||||
{
|
||||
private static async Task Until(Func<bool> condition)
|
||||
{
|
||||
var giveUp = DateTime.UtcNow.AddSeconds(5);
|
||||
while (!condition())
|
||||
{
|
||||
Assert.True(DateTime.UtcNow < giveUp, "waited too long");
|
||||
await Task.Delay(10);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Asked_once_it_runs_once()
|
||||
{
|
||||
int runs = 0;
|
||||
var once = new OneAtATime(() => { runs++; return Task.CompletedTask; });
|
||||
|
||||
await once.RunAsync();
|
||||
|
||||
Assert.Equal(1, runs);
|
||||
Assert.False(once.IsRunning);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Asked_while_running_it_runs_once_more_after_not_alongside()
|
||||
{
|
||||
int runs = 0, together = 0, most = 0;
|
||||
var gates = new Queue<TaskCompletionSource>();
|
||||
var once = new OneAtATime(async () =>
|
||||
{
|
||||
runs++;
|
||||
most = Math.Max(most, ++together);
|
||||
var gate = new TaskCompletionSource();
|
||||
gates.Enqueue(gate);
|
||||
await gate.Task;
|
||||
together--;
|
||||
});
|
||||
|
||||
var first = once.RunAsync();
|
||||
// Three requests during the first run make one more run, not three.
|
||||
await once.RunAsync();
|
||||
await once.RunAsync();
|
||||
await once.RunAsync();
|
||||
Assert.Equal(1, runs);
|
||||
|
||||
gates.Dequeue().SetResult();
|
||||
await Until(() => Volatile.Read(ref runs) == 2);
|
||||
await Until(() => gates.Count == 1);
|
||||
gates.Dequeue().SetResult();
|
||||
await first;
|
||||
|
||||
Assert.Equal(2, runs);
|
||||
Assert.Equal(1, most);
|
||||
Assert.False(once.IsRunning);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_failed_run_does_not_keep_it_busy()
|
||||
{
|
||||
bool fail = true;
|
||||
int runs = 0;
|
||||
var once = new OneAtATime(() =>
|
||||
{
|
||||
runs++;
|
||||
return fail ? Task.FromException(new IOException("locked")) : Task.CompletedTask;
|
||||
});
|
||||
|
||||
await Assert.ThrowsAsync<IOException>(once.RunAsync);
|
||||
fail = false;
|
||||
await once.RunAsync();
|
||||
|
||||
Assert.Equal(2, runs);
|
||||
Assert.False(once.IsRunning);
|
||||
}
|
||||
}
|
||||
45
StarterNG/Application/OneAtATime.cs
Normal file
45
StarterNG/Application/OneAtATime.cs
Normal file
@@ -0,0 +1,45 @@
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StarterNG.Application;
|
||||
|
||||
/// <summary>
|
||||
/// Runs a piece of work one at a time. Asked again while it runs, it does not start a
|
||||
/// second one alongside, nor forget the request: it runs once more when the first ends,
|
||||
/// however many times it was asked meanwhile. For the UI thread, which calls it alone.
|
||||
/// </summary>
|
||||
public sealed class OneAtATime
|
||||
{
|
||||
private readonly Func<Task> _work;
|
||||
private bool _running;
|
||||
private bool _again;
|
||||
|
||||
public OneAtATime(Func<Task> work) => _work = work;
|
||||
|
||||
public bool IsRunning => _running;
|
||||
|
||||
public async Task RunAsync()
|
||||
{
|
||||
if (_running)
|
||||
{
|
||||
_again = true;
|
||||
return;
|
||||
}
|
||||
|
||||
_running = true;
|
||||
try
|
||||
{
|
||||
do
|
||||
{
|
||||
_again = false;
|
||||
await _work();
|
||||
}
|
||||
while (_again);
|
||||
}
|
||||
finally
|
||||
{
|
||||
_running = false;
|
||||
_again = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
55
StarterNG/Infrastructure/Adapters/FolderChanges.cs
Normal file
55
StarterNG/Infrastructure/Adapters/FolderChanges.cs
Normal file
@@ -0,0 +1,55 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
|
||||
namespace StarterNG.Infrastructure.Adapters;
|
||||
|
||||
/// <summary>
|
||||
/// Tells when anything in a folder or below it is written, made, removed or renamed, as
|
||||
/// the system reports it. Only a hint that it is time to look: a save comes as several
|
||||
/// reports, and on a network drive, under Wine or past the system's limit of watches it
|
||||
/// may come as none, so whoever listens still looks now and then on its own.
|
||||
/// </summary>
|
||||
public sealed class FolderChanges : IDisposable
|
||||
{
|
||||
private readonly FileSystemWatcher? _watcher;
|
||||
|
||||
/// <summary>Something changed, or the reports were lost and anything may have: on a thread of the pool.</summary>
|
||||
public event Action? Changed;
|
||||
|
||||
/// <param name="folder">Watched with everything below it; a missing one is not watched.</param>
|
||||
public FolderChanges(string folder)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!Directory.Exists(folder))
|
||||
return;
|
||||
|
||||
var watcher = new FileSystemWatcher(folder)
|
||||
{
|
||||
IncludeSubdirectories = true,
|
||||
NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName
|
||||
| NotifyFilters.LastWrite | NotifyFilters.Size,
|
||||
// Unpacking an update changes hundreds of files at once.
|
||||
InternalBufferSize = 64 * 1024
|
||||
};
|
||||
watcher.Changed += (_, _) => Changed?.Invoke();
|
||||
watcher.Created += (_, _) => Changed?.Invoke();
|
||||
watcher.Deleted += (_, _) => Changed?.Invoke();
|
||||
watcher.Renamed += (_, _) => Changed?.Invoke();
|
||||
// Too many at once for the buffer: which ones is lost, so all are looked at.
|
||||
watcher.Error += (_, _) => Changed?.Invoke();
|
||||
watcher.EnableRaisingEvents = true;
|
||||
_watcher = watcher;
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException
|
||||
or PlatformNotSupportedException)
|
||||
{
|
||||
// Out of watches on Linux, or a drive that gives none: the slow look alone stays.
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Whether the system reports changes here at all.</summary>
|
||||
public bool Watching => _watcher is not null;
|
||||
|
||||
public void Dispose() => _watcher?.Dispose();
|
||||
}
|
||||
96
StarterNG/Infrastructure/FolderLooks.cs
Normal file
96
StarterNG/Infrastructure/FolderLooks.cs
Normal file
@@ -0,0 +1,96 @@
|
||||
using System;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Avalonia.Controls;
|
||||
using Avalonia.Threading;
|
||||
using StarterNG.Application;
|
||||
using StarterNG.Infrastructure.Adapters;
|
||||
|
||||
namespace StarterNG.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// Looks at a folder's files for a window, one look at a time on the UI thread: when the system
|
||||
/// reports a change, once the burst a save makes has passed; when the window comes back to the
|
||||
/// front; when asked; and now and then anyway, for the drives and systems where the reports do
|
||||
/// not come - often where none come at all. From the window's opening to its closing.
|
||||
/// </summary>
|
||||
public sealed class FolderLooks
|
||||
{
|
||||
/// <summary>How long the reports have to stop for: a save comes as several of them.</summary>
|
||||
public static readonly TimeSpan Quiet = TimeSpan.FromMilliseconds(400);
|
||||
|
||||
/// <summary>How often it looks anyway where the system reports the changes.</summary>
|
||||
public static readonly TimeSpan Watched = TimeSpan.FromSeconds(30);
|
||||
|
||||
/// <summary>How often it looks where the system reports nothing.</summary>
|
||||
public static readonly TimeSpan Unwatched = TimeSpan.FromSeconds(2);
|
||||
|
||||
private readonly Func<string> _folder;
|
||||
private readonly OneAtATime _look;
|
||||
private readonly TimeProvider _time;
|
||||
private readonly object _gate = new();
|
||||
private bool _closed;
|
||||
private ITimer? _quiet;
|
||||
private ITimer? _often;
|
||||
private FolderChanges? _changes;
|
||||
|
||||
/// <param name="window">Looked for from its opening to its closing.</param>
|
||||
/// <param name="folder">The folder, as it is when the window opens.</param>
|
||||
/// <param name="look">The look itself; it knows when it is no time to look.</param>
|
||||
/// <param name="time">The clock of the timers, the system's when not given.</param>
|
||||
public FolderLooks(Window window, Func<string> folder, Func<Task> look, TimeProvider? time = null)
|
||||
{
|
||||
_folder = folder;
|
||||
_look = new OneAtATime(look);
|
||||
_time = time ?? TimeProvider.System;
|
||||
window.Opened += (_, _) => Watch();
|
||||
window.Activated += async (_, _) => await LookAsync();
|
||||
window.Closed += (_, _) => Close();
|
||||
}
|
||||
|
||||
/// <summary>Whether the system reports the folder's changes; not before the window opens.</summary>
|
||||
public bool Watching => _changes?.Watching == true;
|
||||
|
||||
/// <summary>Looks now, or once more after the look that runs.</summary>
|
||||
public Task LookAsync() => _look.RunAsync();
|
||||
|
||||
private void Watch()
|
||||
{
|
||||
var changes = new FolderChanges(_folder());
|
||||
var often = changes.Watching ? Watched : Unwatched;
|
||||
lock (_gate)
|
||||
{
|
||||
_changes = changes;
|
||||
_quiet = _time.CreateTimer(_ => LookLater(), null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
|
||||
_often = _time.CreateTimer(_ => LookLater(), null, often, often);
|
||||
}
|
||||
changes.Changed += PutOff;
|
||||
}
|
||||
|
||||
// Each report puts the look off again, so a save of many files is one look after it. The
|
||||
// reports come on threads of the pool, and may come still as the window closes.
|
||||
private void PutOff()
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_closed)
|
||||
_quiet?.Change(Quiet, Timeout.InfiniteTimeSpan);
|
||||
}
|
||||
}
|
||||
|
||||
// The timers tick on threads of the pool; the look belongs on the UI thread.
|
||||
private void LookLater() => Dispatcher.UIThread.Post(() => _ = LookAsync());
|
||||
|
||||
private void Close()
|
||||
{
|
||||
FolderChanges? changes;
|
||||
lock (_gate)
|
||||
{
|
||||
_closed = true;
|
||||
_quiet?.Dispose();
|
||||
_often?.Dispose();
|
||||
changes = _changes;
|
||||
}
|
||||
changes?.Dispose();
|
||||
}
|
||||
}
|
||||
@@ -40,8 +40,9 @@ public partial class MainWindow : Window
|
||||
private DateTime _openedUtc = DateTime.UtcNow;
|
||||
private DateTime _startedUtc = DateTime.MinValue;
|
||||
private bool _starting;
|
||||
private bool _lookingAtSceneryFiles;
|
||||
private readonly DispatcherTimer _sceneryFilesTimer = new() { Interval = TimeSpan.FromSeconds(2) };
|
||||
// Scenery files: looked at when they change, on coming back to the window or from the
|
||||
// simulator, and now and then anyway.
|
||||
private readonly FolderLooks _sceneryLooks;
|
||||
|
||||
public MainWindow()
|
||||
{
|
||||
@@ -107,7 +108,6 @@ public partial class MainWindow : Window
|
||||
|
||||
_openedUtc = DateTime.UtcNow;
|
||||
UpdateStartButton();
|
||||
_sceneryFilesTimer.Start();
|
||||
FollowLastRun();
|
||||
};
|
||||
Activated += (_, _) =>
|
||||
@@ -117,20 +117,20 @@ public partial class MainWindow : Window
|
||||
if (SettingsView.IsVisible)
|
||||
SettingsView.RefreshExecutables();
|
||||
};
|
||||
_sceneryFilesTimer.Tick += async (_, _) => await LookAtSceneryFilesAsync();
|
||||
Closed += (_, _) => _sceneryFilesTimer.Stop();
|
||||
// After the handlers above: back at the window, the settings are checked first.
|
||||
_sceneryLooks = new FolderLooks(this, () => AppServices.Current.Paths.Scenery, LookAtSceneryFilesAsync);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Scenery files changed outside the starter are picked up without a reload. Not
|
||||
/// with the simulator running: it is left in peace, and what it changes comes in after it.
|
||||
/// Run through <see cref="_sceneryLooks"/>, one look at a time.
|
||||
/// </summary>
|
||||
private async Task LookAtSceneryFilesAsync()
|
||||
{
|
||||
if (_lookingAtSceneryFiles || AppServices.Current.State.SimulatorRunning || !IsVisible || WindowState == WindowState.Minimized)
|
||||
if (AppServices.Current.State.SimulatorRunning || !IsVisible || WindowState == WindowState.Minimized)
|
||||
return;
|
||||
|
||||
_lookingAtSceneryFiles = true;
|
||||
try
|
||||
{
|
||||
var services = AppServices.Current;
|
||||
@@ -146,10 +146,6 @@ public partial class MainWindow : Window
|
||||
{
|
||||
Diagnostics.Log("Following the scenery files", ex);
|
||||
}
|
||||
finally
|
||||
{
|
||||
_lookingAtSceneryFiles = false;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -765,6 +761,8 @@ public partial class MainWindow : Window
|
||||
FollowLastRun();
|
||||
RestoreFromSimulator();
|
||||
ReportIfCrashed(simulator, executable, started);
|
||||
// What the simulator or its editor wrote while it ran comes in now.
|
||||
_ = _sceneryLooks.LookAsync();
|
||||
}), TaskScheduler.Default);
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user