/// <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());
}
public static BaseMetroDialog ShowModalDialogExternally(this BaseMetroDialog dialog)
{
Window win = SetupExternalDialogWindow(dialog);
dialog.OnShown();
win.ShowDialog();
return(dialog);
}
private static void SetDialogFontSizes(MetroDialogSettings settings, BaseMetroDialog dialog)
{
if (settings == null)
{
return;
}
if (!double.IsNaN(settings.DialogTitleFontSize))
{
dialog.DialogTitleFontSize = settings.DialogTitleFontSize;
}
if (!double.IsNaN(settings.DialogMessageFontSize))
{
dialog.DialogMessageFontSize = settings.DialogMessageFontSize;
}
}
private static void AddDialog(this MetroWindow window, BaseMetroDialog dialog)
{
window.StoreFocus();
// if there's already an active dialog, move to the background
var activeDialog = window.metroActiveDialogContainer.Children.Cast <UIElement>().SingleOrDefault();
if (activeDialog != null)
{
window.metroActiveDialogContainer.Children.Remove(activeDialog);
window.metroInactiveDialogContainer.Children.Add(activeDialog);
}
window.metroActiveDialogContainer.Children.Add(dialog); //add the dialog to the container}
}
private static Window SetupExternalDialogWindow(BaseMetroDialog dialog)
{
var win = CreateExternalWindow();
try
{
win.Resources.MergedDictionaries.Add(new ResourceDictionary {
Source = new Uri("pack://application:,,,/Pvirtech.Metro;component/Styles/Controls.xaml")
});
win.Resources.MergedDictionaries.Add(new ResourceDictionary {
Source = new Uri("pack://application:,,,/Pvirtech.Metro;component/Styles/Fonts.xaml")
});
win.Resources.MergedDictionaries.Add(new ResourceDictionary {
Source = new Uri("pack://application:,,,/Pvirtech.Metro;component/Styles/Colors.xaml")
});
win.SetResourceReference(MetroWindow.GlowBrushProperty, "AccentColorBrush");
}
catch (Exception) { }
win.Width = SystemParameters.PrimaryScreenWidth;
win.MinHeight = SystemParameters.PrimaryScreenHeight / 4.0;
win.SizeToContent = SizeToContent.Height;
dialog.ParentDialogWindow = win; //THIS IS ONLY, I REPEAT, ONLY SET FOR EXTERNAL DIALOGS!
win.Content = dialog;
EventHandler closedHandler = null;
closedHandler = (sender, args) =>
{
win.Closed -= closedHandler;
dialog.ParentDialogWindow = null;
win.Content = null;
};
win.Closed += closedHandler;
return(win);
}
/// <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());
}
private static Tuple <AppTheme, Accent> DetectTheme(BaseMetroDialog dialog)
{
if (dialog == null)
{
return(null);
}
// first look for owner
var window = dialog.OwningWindow ?? dialog.TryFindParent <MetroWindow>();
var theme = window != null?ThemeManager.DetectAppStyle(window) : null;
if (theme?.Item2 != null)
{
return(theme);
}
// second try, look for main window
if (Application.Current != null)
{
var mainWindow = Application.Current.MainWindow as MetroWindow;
theme = mainWindow != null?ThemeManager.DetectAppStyle(mainWindow) : null;
if (theme?.Item2 != null)
{
return(theme);
}
// oh no, now look at application resource
theme = ThemeManager.DetectAppStyle(Application.Current);
if (theme?.Item2 != null)
{
return(theme);
}
}
return(null);
}
private static void RemoveDialog(this MetroWindow window, BaseMetroDialog dialog)
{
if (window.metroActiveDialogContainer.Children.Contains(dialog))
{
window.metroActiveDialogContainer.Children.Remove(dialog); //remove the dialog from the container
// if there's an inactive dialog, bring it to the front
var dlg = window.metroInactiveDialogContainer.Children.Cast <UIElement>().LastOrDefault();
if (dlg != null)
{
window.metroInactiveDialogContainer.Children.Remove(dlg);
window.metroActiveDialogContainer.Children.Add(dlg);
}
}
else
{
window.metroInactiveDialogContainer.Children.Remove(dialog);
}
if (window.metroActiveDialogContainer.Children.Count == 0)
{
window.RestoreFocus();
}
}
public Task HideMetroDialogAsync(object context, BaseMetroDialog dialog, MetroDialogSettings settings = null)
{
var metroWindow = GetMetroWindow(context);
return(metroWindow.Invoke(() => metroWindow.HideMetroDialogAsync(dialog, settings)));
}
private static SizeChangedEventHandler SetupAndOpenDialog(MetroWindow window, BaseMetroDialog dialog)
{
dialog.SetValue(Panel.ZIndexProperty, (int)window.overlayBox.GetValue(Panel.ZIndexProperty) + 1);
dialog.MinHeight = window.ActualHeight / 4.0;
dialog.MaxHeight = window.ActualHeight;
SizeChangedEventHandler sizeHandler = (sender, args) =>
{
dialog.MinHeight = window.ActualHeight / 4.0;
dialog.MaxHeight = window.ActualHeight;
};
window.SizeChanged += sizeHandler;
window.AddDialog(dialog);
dialog.OnShown();
return(sizeHandler);
}
