/// <summary>
/// Begins a storyboard and waits for it to complete.
/// </summary>
public static async Task BeginAsync(this Storyboard storyboard)
{
await EventAsync.FromEvent <object>(
eh => storyboard.Completed += eh,
eh => storyboard.Completed -= eh,
storyboard.Begin);
}
/// <summary>
/// Waits for the element to load (construct and add to the main object tree).
/// </summary>
public static async Task WaitForLoadedAsync(this FrameworkElement frameworkElement)
{
if (frameworkElement.IsInVisualTree())
{
return;
}
await EventAsync.FromRoutedEvent(
eh => frameworkElement.Loaded += eh,
eh => frameworkElement.Loaded -= eh);
}
public void when_event_fires_then_the_action_is_executed()
{
var testScheduler = new CurrentThreadTaskScheduler();
var stub = new StubClassWithEvent();
var result = false;
EventAsync.FromEvent(eh => stub.NoPayload += eh, eh => stub.NoPayload -= eh)
.Do(() => result = true, testScheduler);
stub.FireNoPayloadEvent();
Assert.That(result, Is.True);
}
public void when_payload_event_is_fired_twice_then_the_second_time_the_event_is_not_recieved()
{
var testScheduler = new CurrentThreadTaskScheduler();
var stub = new StubClassWithEvent();
var count = 0;
EventAsync.FromEvent <DataEventArgs <Guid> >(eh => stub.Payload += eh, eh => stub.Payload -= eh)
.Do(_ => count++, testScheduler);
stub.FirePayloadEvent(Guid.NewGuid());
stub.FirePayloadEvent(Guid.NewGuid());
Assert.That(count, Is.EqualTo(1));
}
private void ConnectUpClosing(IViewModel viewModel, Window window)
{
var supportClosing = viewModel as ISupportClosing;
if (supportClosing == null)
{
return;
}
// ViewModel is closed, so close the Window
supportClosing.ExecuteOnClosed(() => Task.Factory.StartNew(() => window.Close(), _scheduler.Dispatcher.TPL));
// Window is closed, so close the ViewModel
EventAsync.FromEvent(eh => window.Closed += eh, eh => window.Closed -= eh)
.Do(() => supportClosing.ClosingStrategy.Close(), _scheduler.Dispatcher.TPL);
}
public void when_payload_event_fires_then_the_action_is_executed_and_the_payload_is_passed_through()
{
var testScheduler = new CurrentThreadTaskScheduler();
var stub = new StubClassWithEvent();
var result = Guid.Empty;
EventAsync.FromEvent <DataEventArgs <Guid> >(eh => stub.Payload += eh, eh => stub.Payload -= eh)
.Do(payload => result = payload.Value, testScheduler);
var expected = Guid.NewGuid();
stub.FirePayloadEvent(expected);
Assert.That(result.Equals(expected), Is.True);
}
/// <summary>
/// Scrolls to horizontal offset asynchronously.
/// </summary>
/// <param name="scrollViewer">The scroll viewer.</param>
/// <param name="offset">The offset.</param>
/// <returns>The task that completes when scrolling is complete.</returns>
public static async Task ScrollToHorizontalOffsetAsync(this ScrollViewer scrollViewer, double offset)
{
if (offset < 0)
{
offset = 0;
}
if (offset > scrollViewer.ScrollableWidth)
{
offset = scrollViewer.ScrollableWidth;
}
var currentOffset = scrollViewer.HorizontalOffset;
// ReSharper disable CompareOfFloatsByEqualityOperator
if (offset == currentOffset)
{
return;
}
scrollViewer.ScrollToHorizontalOffset(offset);
if (scrollViewer.HorizontalOffset == offset)
{
return;
}
if (scrollViewer.HorizontalOffset != currentOffset)
{
return;
}
// ReSharper restore CompareOfFloatsByEqualityOperator
await EventAsync.FromEvent <ScrollViewerViewChangedEventArgs>(
eh => scrollViewer.ViewChanged += eh,
eh => scrollViewer.ViewChanged -= eh);
}
/// <summary>
/// Scrolls to vertical offset with animation asynchronously.
/// </summary>
/// <param name="scrollViewer">The scroll viewer.</param>
/// <param name="offset">The offset.</param>
/// <returns>The task that completes when scrolling is complete.</returns>
public static async Task ScrollToVerticalOffsetWithAnimationAsync(this ScrollViewer scrollViewer, double offset)
{
if (offset < 0)
{
offset = 0;
}
if (offset > scrollViewer.ScrollableHeight)
{
offset = scrollViewer.ScrollableHeight;
}
var currentOffset = scrollViewer.VerticalOffset;
// ReSharper disable CompareOfFloatsByEqualityOperator
if (offset == currentOffset)
{
return;
}
await scrollViewer.ScrollToVerticalOffsetWithAnimation(offset);
if (scrollViewer.VerticalOffset == offset)
{
return;
}
if (scrollViewer.VerticalOffset != currentOffset)
{
return;
}
// ReSharper restore CompareOfFloatsByEqualityOperator
await EventAsync.FromEvent <ScrollViewerViewChangedEventArgs>(
eh => scrollViewer.ViewChanged += eh,
eh => scrollViewer.ViewChanged -= eh);
}
/// <summary>
/// Waits for the next layout update event.
/// </summary>
/// <param name="frameworkElement">The framework element.</param>
/// <returns></returns>
public static async Task WaitForLayoutUpdateAsync(this FrameworkElement frameworkElement)
{
await EventAsync.FromEvent <object>(
eh => frameworkElement.LayoutUpdated += eh,
eh => frameworkElement.LayoutUpdated -= eh);
}
/// <summary>
/// Waits for the element to unload (disconnect from the main object tree).
/// </summary>
public static async Task WaitForUnloadedAsync(this FrameworkElement frameworkElement)
{
await EventAsync.FromRoutedEvent(
eh => frameworkElement.Unloaded += eh,
eh => frameworkElement.Unloaded -= eh);
}
public async Task <Viewport[]> EditViewportsAsync(ModuleViewportModel value)
{
if (!IsValidViewports(value.Viewports.ToArray()))
{
MessageBoxEx.Show($"One or more viewports were defined on a monitor that is no longer configured, they have been removed.{Environment.NewLine}Make sure you add any missing viewports before saving.", "Invalid Viewport");
}
var tasks = new List <Task>();
var screenIds = GetDeviceViewportMonitorIds();
var devices = _profileSettingsService.GetViewportDevices(value.Module.Value.ModuleId).Where(d => value.Viewports.Any(v => v.SeatIndex == d.SeatIndex)).ToArray();
var windows = new List <Window>();
var viewModels = new List <ViewportEditorWindowViewModel>();
var editorScreens = Screen.AllScreens.Where(s => screenIds.Contains(s.DeviceName));
var overlayScreens = Screen.AllScreens.Where(s => !screenIds.Contains(s.DeviceName) && !value.Viewports.Select(v => v.MonitorId).Contains(s.DeviceName));
foreach (var screen in editorScreens)
{
var viewportModels = new List <ViewportModel>();
foreach (var viewport in value.Viewports.Where(v => v.MonitorId == screen.DeviceName))
{
if (!screenIds.Contains(viewport.MonitorId))
{
continue;
}
var model = new ViewportModel();
model.Height.Value = viewport.Height;
model.InitFile.Value = viewport.RelativeInitFilePath;
model.ImageUrl.Value = Path.Combine(ApplicationPaths.ViewportPath, $"Images/{value.Module.Value.ModuleId}/{viewport.ViewportName}.jpg");
model.Name.Value = viewport.ViewportName;
model.Width.Value = viewport.Width;
model.X.Value = viewport.X;
model.Y.Value = viewport.Y;
viewportModels.Add(model);
}
var window = new ViewportEditorWindow();
var vm = new ViewportEditorWindowViewModel(_container, false, screen.DeviceName, value.Module.Value, devices, viewportModels.ToArray());
vm.Viewports.CollectionChanged += (sender, args) =>
{
OnViewportsChanged(vm, viewModels);
};
window.Screen = screen;
window.DataContext = vm;
window.Show();
window.BringIntoView();
windows.Add(window);
viewModels.Add(vm);
tasks.Add(EventAsync.FromEvent(
handler => window.Closed += handler,
handler => window.Closed -= handler));
}
foreach (var screen in overlayScreens)
{
var window = new MonitorOverlay
{
Screen = screen
};
window.Show();
window.BringIntoView();
windows.Add(window);
tasks.Add(EventAsync.FromEvent(
handler => window.Closed += handler,
handler => window.Closed -= handler));
}
await Task.WhenAny(tasks);
foreach (var window in windows)
{
try
{
window.Close();
}
catch
{
}
}
var save = viewModels.Any(vm => vm.DialogResult.Value == true);
var viewports = new List <Viewport>();
if (save)
{
foreach (var viewModel in viewModels)
{
var screen = Screen.AllScreens.First(s => s.DeviceName == viewModel.MonitorId);
foreach (var viewportModel in viewModel.Viewports)
{
viewports.Add(
new Viewport
{
Height = (int)viewportModel.Height.Value,
MonitorId = screen.DeviceName,
SeatIndex = viewportModel.SeatIndex.Value,
OriginalDisplayHeight = (int)screen.Bounds.Height,
OriginalDisplayWidth = (int)screen.Bounds.Width,
RelativeInitFilePath = viewportModel.InitFile.Value,
ViewportName = viewportModel.Name.Value,
Width = (int)viewportModel.Width.Value,
X = (int)viewportModel.X.Value,
Y = (int)viewportModel.Y.Value
});
}
}
return(viewports.ToArray());
}
else
{
return(value.Viewports.ToArray());
}
}
