/// <summary>
/// Hides a visible Metro Dialog instance.
/// </summary>
/// <param name="window">The window with the dialog that is visible.</param>
/// <param name="dialog">The dialog instance to hide.</param>
/// <param name="settings">An optional pre-defined settings instance.</param>
/// <returns>A task representing the operation.</returns>
/// <exception cref="InvalidOperationException">
/// The <paramref name="dialog"/> is not visible in the window.
/// This happens if <see cref="ShowMetroDialogAsync"/> hasn't been called before.
/// </exception>
public Task HideMetroDialogAsync(
IMetroWindow metroWindow
, IBaseMetroDialogFrame dialog
, IMetroDialogFrameSettings settings = null)
{
metroWindow.Dispatcher.VerifyAccess();
if (!metroWindow.MetroActiveDialogContainer.Children.Contains(dialog as UIElement) && !metroWindow.MetroInactiveDialogContainer.Children.Contains(dialog as UIElement))
{
throw new InvalidOperationException("The provided dialog is not visible in the specified window.");
}
metroWindow.SizeChanged -= dialog.SizeChangedHandler;
dialog.OnClose();
Task closingTask = (Task)metroWindow.Dispatcher.Invoke(new Func <Task>(dialog._WaitForCloseAsync));
return(closingTask.ContinueWith(a =>
{
if (DialogClosed != null)
{
metroWindow.Dispatcher.BeginInvoke(new Action(() => DialogClosed(this, new DialogStateChangedEventArgs())));
}
return (Task)metroWindow.Dispatcher.Invoke(new Func <Task>(() =>
{
this.RemoveDialog(metroWindow, dialog);
return this.HandleOverlayOnHide(metroWindow, settings);
}));
}).Unwrap());
}
/// <summary>
/// Adds a Metro Dialog instance to the specified window and makes it visible asynchronously.
/// If you want to wait until the user has closed the dialog, use <see cref="ShowMetroDialogAsyncAwaitable"/>
/// <para>You have to close the resulting dialog yourself with <see cref="HideMetroDialogAsync"/>.</para>
/// </summary>
/// <param name="window">The owning window of the dialog.</param>
/// <param name="dialog">The dialog instance itself.</param>
/// <param name="settings">An optional pre-defined settings instance.</param>
/// <returns>A task representing the operation.</returns>
/// <exception cref="InvalidOperationException">The <paramref name="dialog"/> is already visible in the window.</exception>
public Task ShowMetroDialogAsync(
IMetroWindow metroWindow
, IBaseMetroDialogFrame dialog
, IMetroDialogFrameSettings settings = null)
{
metroWindow.Dispatcher.VerifyAccess();
if (metroWindow.MetroActiveDialogContainer.Children.Contains(dialog as UIElement) || metroWindow.MetroInactiveDialogContainer.Children.Contains(dialog as UIElement))
{
throw new InvalidOperationException("The provided dialog is already visible in the specified window.");
}
return(this.HandleOverlayOnShow(metroWindow, settings).ContinueWith(z =>
{
return (Task)metroWindow.Dispatcher.Invoke(new Func <Task>(() =>
{
settings = settings ?? new MetroDialogFrameSettings();
SizeChangedEventHandler sizeHandler = this.SetupAndOpenDialog(metroWindow, dialog);
dialog.SizeChangedHandler = sizeHandler;
return dialog.WaitForLoadAsync().ContinueWith(x =>
{
dialog.OnShown();
if (DialogOpened != null)
{
metroWindow.Dispatcher.BeginInvoke(new Action(() => DialogOpened(this, new DialogStateChangedEventArgs())));
}
});
}));
}).Unwrap());
}
public Task HideMetroDialogAsync(object context
, IBaseMetroDialogFrame dialog
, IMetroDialogFrameSettings settings = null)
{
var metroWindow = GetMetroWindow(context);
return(metroWindow.Dispatcher.Invoke(() => _dialogManager.HideMetroDialogAsync(metroWindow, dialog, settings)));
}
/// <summary>
/// Initializes a new DialogFrame object.
/// </summary>
/// <param name="owningWindow">The window that is the parent of the dialog.</param>
/// <param name="settings">The settings for the message dialog.</param>
protected DialogFrame(IMetroWindow owningWindow
, IMetroDialogFrameSettings settings)
: this()
{
DialogSettings = settings ?? new MetroDialogFrameSettings();
OwningWindow = owningWindow;
}
/// <summary>
/// Class constructor
/// </summary>
public ContentDialogServiceImpl()
{
_dialogManager = new DialogManager();
_dialogCoordinator = new DialogCoordinator(_dialogManager);
_MsgBox = new MessageBoxServiceImpl(this);
_DialogSettings = new MetroDialogFrameSettings();
}
/// <summary>
/// Class constructor from parameters.
/// </summary>
/// <param name="parentWindow"></param>
/// <param name="settings"></param>
public CustomDialog(IMetroWindow parentWindow
, IMetroDialogFrameSettings settings)
: base(parentWindow, settings)
{
InitializeComponent();
this.DialogThumb = null;
this.Loaded += MsgBoxDialog_Loaded;
}
public async Task <int> ShowMetroDialogAsync(object context
, IMsgBoxDialogFrame <int> dialog
, IMetroDialogFrameSettings settings = null)
{
var metroWindow = GetMetroWindow(context);
var result = await _dialogManager.ShowMetroDialogAsync(metroWindow, dialog);
return(result);
}
/// <summary>
/// Creates a modal dialog outside of the current main window.
/// </summary>
/// <param name="metroWindow">The MetroWindow</param>
/// <param name="dlgControl">The outside modal window to be owned by a given <seealso cref="IMetroWindow"/></param>
/// <param name="settings">Optional settings that override the global metro dialog settings.</param>
/// <returns>The result that was entered or 0 if the user escape keyed the dialog...</returns>
public int ShowModalDialogExternal(
IMetroWindow metroWindow
, IMsgBoxDialogFrame <int> dlgControl
, IMetroDialogFrameSettings settings = null)
{
settings = settings ?? new MetroDialogFrameSettings();
// Create the outter dialog window that hosts the dialog control
var dlgWindow = _metroWindowService.CreateExternalWindow();
// The window is visible on top of the mainWindow
dlgWindow = CreateModalExternalWindow(metroWindow, dlgWindow);
// Release the dialog opened event if there are any subscribers
if (this.DialogOpened != null)
{
metroWindow.Dispatcher.BeginInvoke(new Action(() => DialogOpened(this, new DialogStateChangedEventArgs())));
}
if (settings.MsgBoxMode == StaticMsgBoxModes.ExternalMoveable)
{
// Relay drag event from thumb to outer window to let user drag the dialog
if (dlgControl.DialogThumb != null && dlgWindow is IMetroWindow)
{
((IMetroWindow)dlgWindow).SetWindowEvents(dlgControl.DialogThumb);
}
}
dlgWindow.Content = dlgControl;
int result = 0;
dlgControl.WaitForButtonPressAsync().ContinueWith(task =>
{
result = task.Result;
dlgWindow.Invoke(dlgWindow.Close);
});
HandleOverlayOnShow(metroWindow, settings);
dlgWindow.ShowDialog();
// Release the dialog closed event if there are any subscribers
if (this.DialogClosed != null)
{
metroWindow.Dispatcher.BeginInvoke(new Action(() => DialogClosed(this, new DialogStateChangedEventArgs())));
}
HandleOverlayOnHide(metroWindow, settings);
return(result);
}
/// <summary>
/// Creates a MsgBoxDialog inside of the current window.
/// </summary>
/// <param name="window">The MetroWindow</param>
/// <param name="title">The title of the MessageDialog.</param>
/// <param name="message">The message contained within the MessageDialog.</param>
/// <param name="style">The type of buttons to use.</param>
/// <param name="settings">Optional settings that override the global metro dialog settings.</param>
/// <returns>A task promising the result of which button was pressed.</returns>
public Task <MsgBoxResult> ShowMsgBoxAsync(
IMetroWindow metroWindow
, IMsgBoxDialogFrame <MsgBoxResult> dialog
, IMetroDialogFrameSettings settings = null)
{
metroWindow.Dispatcher.VerifyAccess();
return(this.HandleOverlayOnShow(metroWindow, settings).ContinueWith(z =>
{
return (Task <MsgBoxResult>)metroWindow.Dispatcher.Invoke(new Func <Task <MsgBoxResult> >(() =>
{
settings = settings ?? new MetroDialogFrameSettings();
SizeChangedEventHandler sizeHandler = this.SetupAndOpenDialog(metroWindow, dialog);
dialog.SizeChangedHandler = sizeHandler;
// Call this method in the dialog to wait until the dialog is closing ...
return dialog.WaitForLoadAsync().ContinueWith(x =>
{
if (DialogOpened != null)
{
metroWindow.Dispatcher.BeginInvoke(new Action(() => DialogOpened(this, new DialogStateChangedEventArgs())));
}
return dialog.WaitForButtonPressAsync().ContinueWith(y =>
{
//once a button as been clicked, begin removing the dialog.
dialog.OnClose();
if (DialogClosed != null)
{
metroWindow.Dispatcher.BeginInvoke(new Action(() => DialogClosed(this, new DialogStateChangedEventArgs())));
}
Task closingTask = (Task)metroWindow.Dispatcher.Invoke(new Func <Task>(() => dialog._WaitForCloseAsync()));
return closingTask.ContinueWith(a =>
{
return ((Task)metroWindow.Dispatcher.Invoke(new Func <Task>(() =>
{
metroWindow.SizeChanged -= sizeHandler;
this.RemoveDialog(metroWindow, dialog);
return this.HandleOverlayOnHide(metroWindow, settings);
}))).ContinueWith(y3 => y).Unwrap();
});
}).Unwrap();
}).Unwrap().Unwrap();
}));
}).Unwrap());
}
private Task HandleOverlayOnShow(IMetroWindow metroWindow
, IMetroDialogFrameSettings settings)
{
if (!metroWindow.MetroActiveDialogContainer.Children.OfType <IBaseMetroDialogFrame>().Any())
{
return(settings == null || settings.AnimateShow ? metroWindow.ShowOverlayAsync() : Task.Factory.StartNew(() => metroWindow.Dispatcher.Invoke(new Action(metroWindow.ShowOverlay))));
}
else
{
var tcs = new System.Threading.Tasks.TaskCompletionSource <object>();
tcs.SetResult(null);
return(tcs.Task);
}
}
/// <summary>
/// Constructor from custom view and optional viewmodel.
/// </summary>
/// <param name="contentView"></param>
/// <param name="viewModel"></param>
/// <param name="settings"></param>
public CustomDialog(object contentView
, object viewModel = null
, IMetroDialogFrameSettings settings = null)
: base(null, settings)
{
InitializeComponent();
// Set the display view here ...
this.PART_Msg_Content.ChromeContent = contentView;
this.DialogThumb = this.PART_Msg_Content.PART_DialogTitleThumb;
// Get a view and bind datacontext to it
this.DataContext = viewModel;
this.Loaded += MsgBoxDialog_Loaded;
}
/// <summary>
/// Constructor from custom view and optional viewmodel.
/// </summary>
/// <param name="parentWindow"></param>
/// <param name="content"></param>
/// <param name="viewnodel"></param>
/// <param name="settings"></param>
internal MsgBoxDialog(IMetroWindow parentWindow
, FrameworkElement content
, object viewnodel = null
, IMetroDialogFrameSettings settings = null)
: base(parentWindow, settings)
{
InitializeComponent();
// Set the display view here ...
this.PART_Msg_Content.ChromeContent = content;
this.DialogThumb = this.PART_Msg_Content.PART_DialogTitleThumb;
// Get a view and bind datacontext to it
this.DataContext = viewnodel;
this.Loaded += MsgBoxDialog_Loaded;
}
/// <summary>
/// Creates an External MsgBox dialog outside of the main window.
/// </summary>
/// <param name="metroWindow"></param>
/// <param name="dlgControl"></param>
/// <param name="settings"></param>
/// <returns></returns>
public MsgBoxResult ShowModalDialogExternal(
IMetroWindow metroWindow
, IMsgBoxDialogFrame <MsgBoxResult> dlgControl
, IMetroDialogFrameSettings settings = null)
{
settings = settings ?? new MetroDialogFrameSettings();
// Create the outter dialog window that hosts the dialog control
var dlgWindow = _metroWindowService.CreateExternalWindow();
// The window is visible on top of the mainWindow
dlgWindow = CreateModalExternalWindow(metroWindow, dlgWindow);
if (settings.MsgBoxMode == StaticMsgBoxModes.ExternalMoveable)
{
// Relay drag event from thumb to outer window to let user drag the dialog
if (dlgControl.DialogThumb != null && dlgWindow is IMetroWindow)
{
((IMetroWindow)dlgWindow).SetWindowEvents(dlgControl.DialogThumb);
}
}
dlgWindow.Content = dlgControl;
MsgBoxResult result = MsgBoxResult.None;
dlgControl.WaitForButtonPressAsync().ContinueWith(task =>
{
result = task.Result;
dlgWindow.Invoke(dlgWindow.Close);
});
HandleOverlayOnShow(metroWindow, settings);
dlgWindow.ShowDialog();
HandleOverlayOnHide(metroWindow, settings);
return(result);
}
