AMT-Cheif
/
Stylet
mirror of https://github.com/AMT-Cheif/Stylet.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Move ShowMessageBox onto the IWindowManager 

Having it as an extension method is good architecturally, but make it harder
to change its behaviour. This way, users can override it easily if they wish.

This also means that the WindowManager does not depend on the IoC service
locator, insteady accepting a Func<IMessageBoxViewModel>
This commit is contained in:
Antony Male 2014-11-29 20:50:21 +00:00
parent aa129f54cd
commit 83557fa29b
5 changed files with 136 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
Stylet/MessageBox.cs
View File

@ -8,33 +8,51 @@ using System.Windows;
namespace Stylet
{
/// <summary>
/// Class holding extension method(s) on IWindowManager, used to show a MessageBox
/// Optional configuration for a MessageBox
/// </summary>
public static class MessageBoxWindowManagerExtensions
public class MessageBoxConfig
{
/// <summary>
/// Show a MessageBox, which looks very similar to the WPF MessageBox, but allows your ViewModel to be unit tested
/// Text to display in the body of the MessageBox
/// </summary>
/// <param name="windowManager">WindowManager to use to display the MessageBox</param>
/// <param name="text">Text to display in the body of the MessageBox</param>
/// <param name="title">Title to display in the titlebar of the MessageBox</param>
/// <param name="buttons">Button, or Buttons, to display on the MessageBox</param>
/// <param name="icon">Icon to display to the left of the text. This also determines the sound played when the MessageBox is shown</param>
/// <param name="defaultButton">Button pressed when the user presses Enter. Defaults to the leftmost button</param>
/// <param name="cancelButton">Button pressed when the user preses Esc or clicks the red X on the titlebar. Defaults to the rightmost button</param>
/// <param name="options">Additional options</param>
/// <param name="buttonLabels">You may override the text for individual buttons on a case-by-case basis</param>
/// <returns>Which button the user clicked</returns>
public static MessageBoxResult ShowMessageBox(this IWindowManager windowManager, string text, string title = "",
MessageBoxButton buttons = MessageBoxButton.OK, MessageBoxImage icon = MessageBoxImage.None,
MessageBoxResult defaultButton = MessageBoxResult.None, MessageBoxResult cancelButton = MessageBoxResult.None,
MessageBoxOptions options = MessageBoxOptions.None,
IDictionary<MessageBoxResult, string> buttonLabels = null)
public MessageBoxButton Buttons { get; set; }
/// <summary>
/// Icon to display to the left of the text. This also determines the sound played when the MessageBox is shown
/// </summary>
public MessageBoxImage Icon { get; set; }
/// <summary>
/// Button pressed when the user presses Enter. Defaults to the leftmost button
/// </summary>
public MessageBoxResult DefaultButton { get; set; }
/// <summary>
/// Button pressed when the user preses Esc or clicks the red X on the titlebar. Defaults to the rightmost button
/// </summary>
public MessageBoxResult CancelButton { get; set; }
/// <summary>
/// Additional options
/// </summary>
public MessageBoxOptions Options { get; set; }
/// <summary>
/// You may override the text for individual buttons on a case-by-case basis
/// </summary>
public IDictionary<MessageBoxResult, string> ButtonLabels { get; set; }
/// <summary>
/// Create a new instance with default configuration
/// </summary>
public MessageBoxConfig()
{
var vm = IoC.Get<IMessageBoxViewModel>();
vm.Setup(text, title, buttons, icon, defaultButton, cancelButton, options, buttonLabels);
windowManager.ShowDialog(vm);
return vm.ClickedButton;
this.Buttons = MessageBoxButton.OK;
this.Icon = MessageBoxImage.None;
this.DefaultButton = MessageBoxResult.None;
this.CancelButton = MessageBoxResult.None;
this.Options = MessageBoxOptions.None;
this.ButtonLabels = null;
}
}
@ -48,15 +66,8 @@ namespace Stylet
/// </summary>
/// <param name="text">Text to display in the body of the MessageBox</param>
/// <param name="title">Title to display in the titlebar of the MessageBox</param>
/// <param name="buttons">Button, or Buttons, to display on the MessageBox</param>
/// <param name="icon">Icon to display to the left of the text. This also determines the sound played when the MessageBox is shown</param>
/// <param name="defaultButton">Button pressed when the user presses Enter. Defaults to the leftmost button</param>
/// <param name="cancelButton">Button pressed when the user preses Esc or clicks the red X on the titlebar. Defaults to the rightmost button</param>
/// <param name="options">Additional options</param>
/// <param name="buttonLabels">You may override the text for individual buttons on a case-by-case basis</param>
void Setup(string text, string title, MessageBoxButton buttons, MessageBoxImage icon,
MessageBoxResult defaultButton, MessageBoxResult cancelButton, MessageBoxOptions options,
IDictionary<MessageBoxResult, string> buttonLabels = null);
/// <param name="config">Other configuration. Optional</param>
void Setup(string text, string title, MessageBoxConfig config = null);
/// <summary>
/// After the user has clicked a button, holds which button was clicked
@ -132,53 +143,48 @@ namespace Stylet
/// </summary>
/// <param name="text">Text to display in the body of the MessageBox</param>
/// <param name="title">Title to display in the titlebar of the MessageBox</param>
/// <param name="buttons">Button, or Buttons, to display on the MessageBox</param>
/// <param name="icon">Icon to display to the left of the text. This also determines the sound played when the MessageBox is shown</param>
/// <param name="defaultButton">Button pressed when the user presses Enter. Defaults to the leftmost button</param>
/// <param name="cancelButton">Button pressed when the user preses Esc or clicks the red X on the titlebar. Defaults to the rightmost button</param>
/// <param name="options">Additional options</param>
/// <param name="buttonLabels">You may override the text for individual buttons on a case-by-case basis</param>
public void Setup(string text, string title, MessageBoxButton buttons, MessageBoxImage icon,
MessageBoxResult defaultButton, MessageBoxResult cancelButton, MessageBoxOptions options,
IDictionary<MessageBoxResult, string> buttonLabels)
/// <param name="config">Other configuration. Optional</param>
public void Setup(string text, string title, MessageBoxConfig config = null)
{
config = config ?? new MessageBoxConfig();
this.Text = text;
this.DisplayName = title;
this.Icon = icon;
this.Icon = config.Icon;
var buttonList = new List<LabelledValue<MessageBoxResult>>();
this.ButtonList = buttonList;
foreach (var val in ButtonToResults[buttons])
foreach (var val in ButtonToResults[config.Buttons])
{
string label;
if (buttonLabels == null || !buttonLabels.TryGetValue(val, out label))
if (config.ButtonLabels == null || !config.ButtonLabels.TryGetValue(val, out label))
label = ButtonLabels[val];
var lbv = new LabelledValue<MessageBoxResult>(label, val);
buttonList.Add(lbv);
if (val == defaultButton)
if (val == config.DefaultButton)
this.DefaultButton = lbv;
else if (val == cancelButton)
else if (val == config.CancelButton)
this.CancelButton = lbv;
}
// If they didn't specify a button which we showed, then pick a default, if we can
if (this.DefaultButton == null)
{
if (defaultButton == MessageBoxResult.None && this.ButtonList.Any())
if (config.DefaultButton == MessageBoxResult.None && this.ButtonList.Any())
this.DefaultButton = buttonList[0];
else
throw new ArgumentException("DefaultButton set to a button which doesn't appear in Buttons");
}
if (this.CancelButton == null)
{
if (cancelButton == MessageBoxResult.None && this.ButtonList.Any())
if (config.CancelButton == MessageBoxResult.None && this.ButtonList.Any())
this.CancelButton = buttonList.Last();
else
throw new ArgumentException("CancelButton set to a button which doesn't appear in Buttons");
}
this.FlowDirection = options.HasFlag(MessageBoxOptions.RtlReading) ? FlowDirection.RightToLeft : FlowDirection.LeftToRight;
this.TextAlignment = (options.HasFlag(MessageBoxOptions.RightAlign) == options.HasFlag(MessageBoxOptions.RtlReading)) ? TextAlignment.Left : TextAlignment.Right;
this.FlowDirection = config.Options.HasFlag(MessageBoxOptions.RtlReading) ? FlowDirection.RightToLeft : FlowDirection.LeftToRight;
this.TextAlignment = (config.Options.HasFlag(MessageBoxOptions.RightAlign) == config.Options.HasFlag(MessageBoxOptions.RtlReading)) ? TextAlignment.Left : TextAlignment.Right;
}
/// <summary>

30
Stylet/WindowManager.cs
View File

@ -1,5 +1,6 @@
using Stylet.Logging;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Windows;
@ -24,6 +25,14 @@ namespace Stylet
/// <param name="viewModel">ViewModel to show the View for</param>
/// <returns>DialogResult of the View</returns>
bool? ShowDialog(object viewModel);
/// <summary>
/// Setup the MessageBoxViewModel with the information it needs
/// </summary>
/// <param name="text">Text to display in the body of the MessageBox</param>
/// <param name="title">Title to display in the titlebar of the MessageBox</param>
/// <param name="config">Other configuration. Optional</param>
MessageBoxResult ShowMessageBox(string text, string title = "", MessageBoxConfig config = null);
}
/// <summary>
@ -32,15 +41,18 @@ namespace Stylet
public class WindowManager : IWindowManager
{
private static readonly ILogger logger = LogManager.GetLogger(typeof(WindowManager));
private IViewManager viewManager;
private readonly IViewManager viewManager;
private readonly Func<IMessageBoxViewModel> messageBoxViewModelFactory;
/// <summary>
/// Create a new WindowManager instance, using the given IViewManager
/// </summary>
/// <param name="viewManager">IViewManager to use when creating views</param>
public WindowManager(IViewManager viewManager)
/// <param name="messageBoxViewModelFactory">Delegate which returns a new IMessageBoxViewModel instance when invoked</param>
public WindowManager(IViewManager viewManager, Func<IMessageBoxViewModel> messageBoxViewModelFactory)
{
this.viewManager = viewManager;
this.messageBoxViewModelFactory = messageBoxViewModelFactory;
}
/// <summary>
@ -62,6 +74,20 @@ namespace Stylet
return this.CreateWindow(viewModel, true).ShowDialog();
}
/// <summary>
/// Setup the MessageBoxViewModel with the information it needs
/// </summary>
/// <param name="text">Text to display in the body of the MessageBox</param>
/// <param name="title">Title to display in the titlebar of the MessageBox</param>
/// <param name="config">Other configuration. Optional</param>
public MessageBoxResult ShowMessageBox(string text, string title = "", MessageBoxConfig config = null)
{
var vm = this.messageBoxViewModelFactory();
vm.Setup(text, title, config);
this.ShowDialog(vm);
return vm.ClickedButton;
}
/// <summary>
/// Given a ViewModel, create its View, ensure that it's a Window, and set it up
/// </summary>

2
StyletIntegrationTests/ShellViewModel.cs
View File

@ -60,7 +60,7 @@ namespace StyletIntegrationTests
await Task.Delay(100);
if (log.SequenceEqual(new[] { "One", "Two", "Four", "Three" }))
this.windowManager.ShowMessageBox("Success", icon: MessageBoxImage.Information);
this.windowManager.ShowMessageBox("Success", config: new MessageBoxConfig() { Icon = MessageBoxImage.Information });
else
this.windowManager.ShowMessageBox("Failure");
}

66
StyletUnitTests/MessageBoxTests.cs
View File

@ -30,46 +30,24 @@ namespace StyletUnitTests
this.vm = new MessageBoxViewModel();
}
[Test]
public void ShowMessageBoxShowsMessageBox()
{
var vm = new Mock<IMessageBoxViewModel>();
IoC.GetInstance = (o, k) =>
{
Assert.AreEqual(typeof(IMessageBoxViewModel), o);
Assert.AreEqual(null, k);
return vm.Object;
};
var windowManager = new Mock<IWindowManager>();
vm.SetupGet(x => x.ClickedButton).Returns(MessageBoxResult.OK);
var result = MessageBoxWindowManagerExtensions.ShowMessageBox(windowManager.Object, "this is the text", "this is the title", MessageBoxButton.OKCancel, MessageBoxImage.Exclamation, MessageBoxResult.OK, MessageBoxResult.Cancel);
vm.Verify(x => x.Setup("this is the text", "this is the title", MessageBoxButton.OKCancel, MessageBoxImage.Exclamation, MessageBoxResult.OK, MessageBoxResult.Cancel, MessageBoxOptions.None, null));
windowManager.Verify(x => x.ShowDialog(vm.Object));
Assert.AreEqual(MessageBoxResult.OK, result);
}
[Test]
public void SetsTextCorrectly()
{
this.vm.Setup("this is the text", null, MessageBoxButton.OK, System.Windows.MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.None, null);
this.vm.Setup("this is the text", null);
Assert.AreEqual("this is the text", this.vm.Text);
}
[Test]
public void SetsTitleCorrectly()
{
this.vm.Setup(null, "this is the title", MessageBoxButton.OK, System.Windows.MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.None, null);
this.vm.Setup(null, "this is the title");
Assert.AreEqual("this is the title", this.vm.DisplayName);
}
[Test]
public void DisplaysRequestedButtons()
{
this.vm.Setup(null, null, MessageBoxButton.OKCancel, System.Windows.MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.None, null);
this.vm.Setup(null, null, new MessageBoxConfig() { Buttons = MessageBoxButton.OKCancel });
var buttons = vm.ButtonList.ToList();
Assert.AreEqual(2, buttons.Count);
Assert.AreEqual("OK", buttons[0].Label);
@ -81,47 +59,47 @@ namespace StyletUnitTests
[Test]
public void SetsDefaultButtonToTheRequestedButton()
{
this.vm.Setup(null, null, MessageBoxButton.OKCancel, System.Windows.MessageBoxImage.None, MessageBoxResult.Cancel, MessageBoxResult.None, MessageBoxOptions.None, null);
this.vm.Setup(null, null, new MessageBoxConfig() { Buttons = MessageBoxButton.OKCancel, DefaultButton = MessageBoxResult.Cancel });
Assert.AreEqual(this.vm.ButtonList.ElementAt(1), this.vm.DefaultButton);
}
[Test]
public void SetsDefaultToLeftmostButtonIfDefaultRequested()
{
this.vm.Setup(null, null, MessageBoxButton.YesNoCancel, System.Windows.MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.None, null);
this.vm.Setup(null, null, new MessageBoxConfig() { Buttons = MessageBoxButton.YesNoCancel });
Assert.AreEqual(this.vm.ButtonList.ElementAt(0), this.vm.DefaultButton);
}
[Test]
public void ThrowsIfTheRequestedDefaultButtonIsNotDisplayed()
{
Assert.Throws<ArgumentException>(() => this.vm.Setup(null, null, MessageBoxButton.OKCancel, MessageBoxImage.None, MessageBoxResult.Yes, MessageBoxResult.None, MessageBoxOptions.None, null));
Assert.Throws<ArgumentException>(() => this.vm.Setup(null, null, new MessageBoxConfig() { Buttons = MessageBoxButton.OKCancel, DefaultButton = MessageBoxResult.Yes }));
}
[Test]
public void SetsCancelButtonToTheRequestedButton()
{
this.vm.Setup(null, null, MessageBoxButton.YesNoCancel, MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.No, MessageBoxOptions.None, null);
this.vm.Setup(null, null, new MessageBoxConfig() { Buttons = MessageBoxButton.YesNoCancel, CancelButton = MessageBoxResult.No });
Assert.AreEqual(this.vm.ButtonList.ElementAt(1), this.vm.CancelButton);
}
[Test]
public void SetsCancelToRighmostButtonIfDefaultRequested()
{
this.vm.Setup(null, null, MessageBoxButton.OKCancel, MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.None, null);
this.vm.Setup(null, null, new MessageBoxConfig() { Buttons = MessageBoxButton.OKCancel });
Assert.AreEqual(this.vm.ButtonList.ElementAt(1), this.vm.CancelButton);
}
[Test]
public void ThrowsIfRequestedCancelButtonIsNotDisplayed()
{
Assert.Throws<ArgumentException>(() => this.vm.Setup(null, null, MessageBoxButton.OK, MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.No, MessageBoxOptions.None, null));
Assert.Throws<ArgumentException>(() => this.vm.Setup(null, null, new MessageBoxConfig() { CancelButton = MessageBoxResult.No }));
}
[Test]
public void SetsIconCorrectly()
{
this.vm.Setup(null, null, MessageBoxButton.OK, MessageBoxImage.Exclamation, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.None, null);
this.vm.Setup(null, null, new MessageBoxConfig() { Icon = MessageBoxImage.Exclamation });
Assert.AreEqual(SystemIcons.Exclamation, this.vm.ImageIcon);
}
@ -130,7 +108,7 @@ namespace StyletUnitTests
{
var parent = new Mock<IChildDelegate>();
this.vm.Parent = parent.Object;
this.vm.Setup(null, null, MessageBoxButton.OK, MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.None, null);
this.vm.Setup(null, null);
this.vm.ButtonClicked(MessageBoxResult.No);
@ -143,17 +121,21 @@ namespace StyletUnitTests
{
var vm = new MyMessageBoxViewModel();
// Can't test it actually playing the sound
vm.Setup(null, null, MessageBoxButton.OK, MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.None, null);
vm.Setup(null, null);
Assert.DoesNotThrow(() => vm.OnViewLoaded());
}
[Test]
public void ButtonTextOverridesWork()
{
this.vm.Setup(null, null, MessageBoxButton.OKCancel, MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.None, new Dictionary<MessageBoxResult, string>()
this.vm.Setup(null, null, new MessageBoxConfig()
{
Buttons = MessageBoxButton.OKCancel,
ButtonLabels = new Dictionary<MessageBoxResult, string>()
{
{ MessageBoxResult.Cancel, "YAY!" },
});
}
});
Assert.AreEqual("OK", this.vm.ButtonList.ElementAt(0).Label);
Assert.AreEqual("YAY!", this.vm.ButtonList.ElementAt(1).Label);
}
@ -161,42 +143,42 @@ namespace StyletUnitTests
[Test]
public void FlowsLeftToRightByDefault()
{
this.vm.Setup(null, null, MessageBoxButton.OK, MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.None, null);
this.vm.Setup(null, null);
Assert.AreEqual(FlowDirection.LeftToRight, this.vm.FlowDirection);
}
[Test]
public void FlowsRightToLeftIfRequested()
{
this.vm.Setup(null, null, MessageBoxButton.OK, MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.RtlReading, null);
this.vm.Setup(null, null, new MessageBoxConfig() { Options = MessageBoxOptions.RtlReading });
Assert.AreEqual(FlowDirection.RightToLeft, this.vm.FlowDirection);
}
[Test]
public void AlignsLeftIfLeftToRightByDefault()
{
this.vm.Setup(null, null, MessageBoxButton.OK, MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.None, null);
this.vm.Setup(null, null);
Assert.AreEqual(TextAlignment.Left, this.vm.TextAlignment);
}
[Test]
public void AlignsRightIfLeftToRightAndRequested()
{
this.vm.Setup(null, null, MessageBoxButton.OK, MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.RightAlign, null);
this.vm.Setup(null, null, new MessageBoxConfig() { Options = MessageBoxOptions.RightAlign });
Assert.AreEqual(TextAlignment.Right, this.vm.TextAlignment);
}
[Test]
public void AlignsRightIfRightToLeftByDefault()
{
this.vm.Setup(null, null, MessageBoxButton.OK, MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.RtlReading, null);
this.vm.Setup(null, null, new MessageBoxConfig() { Options = MessageBoxOptions.RtlReading });
Assert.AreEqual(TextAlignment.Right, this.vm.TextAlignment);
}
[Test]
public void AlignsLeftIfRightToLeftAndRequested()
{
this.vm.Setup(null, null, MessageBoxButton.OK, MessageBoxImage.None, MessageBoxResult.None, MessageBoxResult.None, MessageBoxOptions.RightAlign | MessageBoxOptions.RtlReading, null);
this.vm.Setup(null, null, new MessageBoxConfig() { Options = MessageBoxOptions.RightAlign | MessageBoxOptions.RtlReading });
Assert.AreEqual(TextAlignment.Left, this.vm.TextAlignment);
}
}

30
StyletUnitTests/WindowManagerTests.cs
View File

@ -18,9 +18,11 @@ namespace StyletUnitTests
public interface IMyScreen : IScreen, IDisposable
{ }
private class TestException : Exception { }
private class MyWindowManager : WindowManager
{
public MyWindowManager(IViewManager viewManager) : base(viewManager) { }
public MyWindowManager(IViewManager viewManager, Func<IMessageBoxViewModel> messageBoxViewModelFactory) : base(viewManager, messageBoxViewModelFactory) { }
public new Window CreateWindow(object viewModel, bool isDialog)
{
@ -28,6 +30,16 @@ namespace StyletUnitTests
}
}
private class WindowManagerWithoutCreateWindow : WindowManager
{
public WindowManagerWithoutCreateWindow(IViewManager viewManager, Func<IMessageBoxViewModel> messageBoxViewModelFactory) : base(viewManager, messageBoxViewModelFactory) { }
protected override Window CreateWindow(object viewModel, bool isDialog)
{
throw new TestException(); // ABORT! ABORT!
}
}
private class MyWindow : Window
{
public new void OnClosing(CancelEventArgs e)
@ -49,13 +61,15 @@ namespace StyletUnitTests
}
private Mock<IViewManager> viewManager;
private Mock<IMessageBoxViewModel> messageBoxViewModel;
private MyWindowManager windowManager;
[SetUp]
public void SetUp()
{
this.viewManager = new Mock<IViewManager>();
this.windowManager = new MyWindowManager(this.viewManager.Object);
this.messageBoxViewModel = new Mock<IMessageBoxViewModel>();
this.windowManager = new MyWindowManager(this.viewManager.Object, () => this.messageBoxViewModel.Object);
IoC.GetInstance = (service, key) => this.viewManager.Object;
}
@ -263,5 +277,17 @@ namespace StyletUnitTests
model.Verify(x => x.Dispose());
Assert.True(window.OnClosedCalled);
}
[Test]
public void ShowMessageBoxShowsMessageBox()
{
var config = new MessageBoxConfig();
var wm = new WindowManagerWithoutCreateWindow(this.viewManager.Object, () => this.messageBoxViewModel.Object);
try { wm.ShowMessageBox("text", "title", config); }
catch (TestException) { }
this.messageBoxViewModel.Verify(x => x.Setup("text", "title", config));
}
}
}