/// <summary>
/// Creates a MessageDialog ouside 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 static MessageDialogResult ShowModalMessageExternal(this MetroWindow window, string title, string message, MessageDialogStyle style = MessageDialogStyle.Affirmative, MetroDialogSettings settings = null)
{
var win = CreateModalExternalWindow(window);
settings = settings ?? window.MetroDialogOptions;
//create the dialog control
var dialog = new MessageDialog(window, settings)
{
Message = message,
Title = title,
ButtonStyle = style
};
SetDialogFontSizes(settings, dialog);
win.Content = dialog;
MessageDialogResult result = MessageDialogResult.Affirmative;
dialog.WaitForButtonPressAsync().ContinueWith(task =>
{
result = task.Result;
win.Invoke(win.Close);
});
HandleOverlayOnShow(settings, window);
win.ShowDialog();
HandleOverlayOnHide(settings, window);
return(result);
}
/// <summary>
/// Creates a InputDialog 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="settings">Optional settings that override the global metro dialog settings.</param>
/// <returns>The text that was entered or null (Nothing in Visual Basic) if the user cancelled the operation.</returns>
public static Task <string> ShowInputAsync(this MetroWindow window, string title, string message, MetroDialogSettings settings = null)
{
window.Dispatcher.VerifyAccess();
return(HandleOverlayOnShow(settings, window).ContinueWith(z =>
{
return (Task <string>)window.Dispatcher.Invoke(new Func <Task <string> >(() =>
{
settings = settings ?? window.MetroDialogOptions;
//create the dialog control
var dialog = new InputDialog(window, settings)
{
Title = title,
Message = message,
Input = settings.DefaultText,
};
SetDialogFontSizes(settings, dialog);
SizeChangedEventHandler sizeHandler = SetupAndOpenDialog(window, dialog);
dialog.SizeChangedHandler = sizeHandler;
return dialog.WaitForLoadAsync().ContinueWith(x =>
{
if (DialogOpened != null)
{
window.Dispatcher.BeginInvoke(new Action(() => DialogOpened(window, new DialogStateChangedEventArgs())));
}
return dialog.WaitForButtonPressAsync().ContinueWith(y =>
{
//once a button as been clicked, begin removing the dialog.
dialog.OnClose();
if (DialogClosed != null)
{
window.Dispatcher.BeginInvoke(new Action(() => DialogClosed(window, new DialogStateChangedEventArgs())));
}
Task closingTask = (Task)window.Dispatcher.Invoke(new Func <Task>(() => dialog._WaitForCloseAsync()));
return closingTask.ContinueWith(a =>
{
return ((Task)window.Dispatcher.Invoke(new Func <Task>(() =>
{
window.SizeChanged -= sizeHandler;
window.RemoveDialog(dialog);
return HandleOverlayOnHide(settings, window);
}))).ContinueWith(y3 => y).Unwrap();
});
}).Unwrap();
}).Unwrap().Unwrap();
}));
}).Unwrap());
}
/// <summary>
/// Creates a InputDialog outside 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="settings">Optional settings that override the global metro dialog settings.</param>
/// <returns>The text that was entered or null (Nothing in Visual Basic) if the user cancelled the operation.</returns>
public static string ShowModalInputExternal(this MetroWindow window, string title, string message, MetroDialogSettings settings = null)
{
var win = CreateModalExternalWindow(window);
settings = settings ?? window.MetroDialogOptions;
//create the dialog control
var dialog = new InputDialog(window, settings)
{
Message = message,
Title = title,
Input = settings.DefaultText
};
SetDialogFontSizes(settings, dialog);
win.Content = dialog;
string result = null;
dialog.WaitForButtonPressAsync().ContinueWith(task =>
{
result = task.Result;
win.Invoke(win.Close);
});
HandleOverlayOnShow(settings, window);
win.ShowDialog();
HandleOverlayOnHide(settings, window);
return(result);
}
/// <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 static Task HideMetroDialogAsync(this MetroWindow window, BaseMetroDialog dialog, MetroDialogSettings settings = null)
{
window.Dispatcher.VerifyAccess();
if (!window.metroActiveDialogContainer.Children.Contains(dialog) && !window.metroInactiveDialogContainer.Children.Contains(dialog))
{
throw new InvalidOperationException("The provided dialog is not visible in the specified window.");
}
window.SizeChanged -= dialog.SizeChangedHandler;
dialog.OnClose();
Task closingTask = (Task)window.Dispatcher.Invoke(new Func <Task>(dialog._WaitForCloseAsync));
return(closingTask.ContinueWith(a =>
{
if (DialogClosed != null)
{
window.Dispatcher.BeginInvoke(new Action(() => DialogClosed(window, new DialogStateChangedEventArgs())));
}
return (Task)window.Dispatcher.Invoke(new Func <Task>(() =>
{
window.RemoveDialog(dialog);
settings = settings ?? (dialog.DialogSettings ?? window.MetroDialogOptions);
return HandleOverlayOnHide(settings, window);
}));
}).Unwrap());
}
/// <summary>
/// Adds a Metro Dialog instance of the given type to the specified window and makes it visible asynchronously.
/// If you want to wait until the user has closed the dialog, use <see cref="BaseMetroDialog.WaitUntilUnloadedAsync"/>
/// <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="settings">An optional pre-defined settings instance.</param>
/// <returns>A task with the dialog representing the operation.</returns>
public static Task <TDialog> ShowMetroDialogAsync <TDialog>([NotNull] this MetroWindow window, [CanBeNull] MetroDialogSettings settings = null) where TDialog : BaseMetroDialog
{
if (window == null)
{
throw new ArgumentNullException(nameof(window));
}
window.Dispatcher.VerifyAccess();
var dialog = (TDialog)Activator.CreateInstance(typeof(TDialog), window, settings);
return(HandleOverlayOnShow(dialog.DialogSettings, window).ContinueWith(z =>
{
return (Task <TDialog>)window.Dispatcher.Invoke(new Func <Task <TDialog> >(() =>
{
SetDialogFontSizes(dialog.DialogSettings, dialog);
SizeChangedEventHandler sizeHandler = SetupAndOpenDialog(window, dialog);
dialog.SizeChangedHandler = sizeHandler;
return dialog.WaitForLoadAsync().ContinueWith(x =>
{
dialog.OnShown();
if (DialogOpened != null)
{
window.Dispatcher.BeginInvoke(new Action(() => DialogOpened(window, new DialogStateChangedEventArgs())));
}
}).ContinueWith(x => dialog);
}));
}).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="BaseMetroDialog.WaitUntilUnloadedAsync"/>
/// <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 static Task ShowMetroDialogAsync([NotNull] this MetroWindow window, [NotNull] BaseMetroDialog dialog, [CanBeNull] MetroDialogSettings settings = null)
{
if (window == null)
{
throw new ArgumentNullException(nameof(window));
}
window.Dispatcher.VerifyAccess();
if (dialog == null)
{
throw new ArgumentNullException(nameof(dialog));
}
if (window.metroActiveDialogContainer.Children.Contains(dialog) || window.metroInactiveDialogContainer.Children.Contains(dialog))
{
throw new InvalidOperationException("The provided dialog is already visible in the specified window.");
}
settings = settings ?? (dialog.DialogSettings ?? window.MetroDialogOptions);
return(HandleOverlayOnShow(settings, window).ContinueWith(z =>
{
return (Task)window.Dispatcher.Invoke(new Func <Task>(() =>
{
SetDialogFontSizes(settings, dialog);
SizeChangedEventHandler sizeHandler = SetupAndOpenDialog(window, dialog);
dialog.SizeChangedHandler = sizeHandler;
return dialog.WaitForLoadAsync().ContinueWith(x =>
{
dialog.OnShown();
if (DialogOpened != null)
{
window.Dispatcher.BeginInvoke(new Action(() => DialogOpened(window, new DialogStateChangedEventArgs())));
}
});
}));
}).Unwrap());
}
/// <summary>
/// Creates a ProgressDialog inside of the current window.
/// </summary>
/// <param name="window">The MetroWindow</param>
/// <param name="title">The title of the ProgressDialog.</param>
/// <param name="message">The message within the ProgressDialog.</param>
/// <param name="isCancelable">Determines if the cancel button is visible.</param>
/// <param name="settings">Optional Settings that override the global metro dialog settings.</param>
/// <returns>A task promising the instance of ProgressDialogController for this operation.</returns>
public static Task <ProgressDialogController> ShowProgressAsync(this MetroWindow window, string title, string message, bool isCancelable = false, MetroDialogSettings settings = null)
{
window.Dispatcher.VerifyAccess();
return(HandleOverlayOnShow(settings, window).ContinueWith(z =>
{
return ((Task <ProgressDialogController>)window.Dispatcher.Invoke(new Func <Task <ProgressDialogController> >(() =>
{
settings = settings ?? window.MetroDialogOptions;
//create the dialog control
var dialog = new ProgressDialog(window, settings)
{
Title = title,
Message = message,
IsCancelable = isCancelable
};
SetDialogFontSizes(settings, dialog);
SizeChangedEventHandler sizeHandler = SetupAndOpenDialog(window, dialog);
dialog.SizeChangedHandler = sizeHandler;
return dialog.WaitForLoadAsync().ContinueWith(x =>
{
if (DialogOpened != null)
{
window.Dispatcher.BeginInvoke(new Action(() => DialogOpened(window, new DialogStateChangedEventArgs())));
}
return new ProgressDialogController(dialog, () =>
{
dialog.OnClose();
if (DialogClosed != null)
{
window.Dispatcher.BeginInvoke(new Action(() => DialogClosed(window, new DialogStateChangedEventArgs())));
}
Task closingTask = (Task)window.Dispatcher.Invoke(new Func <Task>(() => dialog._WaitForCloseAsync()));
return closingTask.ContinueWith(a =>
{
return (Task)window.Dispatcher.Invoke(new Func <Task>(() =>
{
window.SizeChanged -= sizeHandler;
window.RemoveDialog(dialog);
return HandleOverlayOnHide(settings, window);
}));
}).Unwrap();
});
});
})));
}).Unwrap());
}