internal async Task <object> ShowInternal(object content, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
if (IsOpen)
{
throw new InvalidOperationException("DialogHost is already open.");
}
_dialogTaskCompletionSource = new TaskCompletionSource <object>();
AssertTargetableContent();
if (content != null)
{
DialogContent = content;
}
_asyncShowOpenedEventHandler = openedEventHandler;
_asyncShowClosingEventHandler = closingEventHandler;
SetCurrentValue(IsOpenProperty, true);
object result = await _dialogTaskCompletionSource.Task;
_asyncShowOpenedEventHandler = null;
_asyncShowClosingEventHandler = null;
return(result);
}
/// <summary>
/// Shows a modal dialog. To use, a <see cref="DialogHost"/> instance must be in a visual tree (typically this may be specified towards the root of a Window's XAML).
/// </summary>
/// <param name="content">Content to show (can be a control or view model).</param>
/// <param name="dialogIdentifier"><see cref="Identifier"/> of the instance where the dialog should be shown. Typically this will match an identifer set in XAML. <c>null</c> is allowed.</param>
/// <param name="openedEventHandler">Allows access to opened event which would otherwise have been subscribed to on a instance.</param>
/// <param name="closingEventHandler">Allows access to closing event which would otherwise have been subscribed to on a instance.</param>
/// <returns>Task result is the parameter used to close the dialog, typically what is passed to the <see cref="CloseDialogCommand"/> command.</returns>
public static Task <object> Show(object content, object dialogIdentifier, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
if (LoadedInstances.Count == 0)
{
throw new InvalidOperationException("No loaded DialogHost instances.");
}
LoadedInstances.First().Dispatcher.VerifyAccess();
var targets = LoadedInstances.Where(dh => dialogIdentifier == null || Equals(dh.Identifier, dialogIdentifier)).ToList();
if (targets.Count == 0)
{
throw new InvalidOperationException("No loaded DialogHost have an Identifier property matching dialogIndetifier argument.");
}
if (targets.Count > 1)
{
throw new InvalidOperationException("Multiple viable DialogHosts. Specify a unique Identifier on each DialogHost, especially where multiple Windows are a concern.");
}
return(targets[0].ShowInternal(content, openedEventHandler, closingEventHandler));
}
/// <summary>
/// 弹出窗口
/// </summary>
/// <param name="openedEventHandler"></param>
/// <param name="closingEventHandler"></param>
/// <returns></returns>
public async virtual Task <bool> ShowDialog(DialogOpenedEventHandler openedEventHandler = null, DialogClosingEventHandler closingEventHandler = null)
{
var dialog = GetDialog();
object taskResult = await DialogHost.Show(dialog, "RootDialog", openedEventHandler, closingEventHandler); //位于顶级窗口
return((bool)taskResult);
}
internal Task <object> ShowInternal(object content, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
if (IsOpen)
{
throw new InvalidOperationException("DialogHost is already open.");
}
AssertTargetableContent();
DialogContent = content;
_asyncShowOpenedEventHandler = openedEventHandler;
_asyncShowClosingEventHandler = closingEventHandler;
SetCurrentValue(IsOpenProperty, true);
var task = new Task(() =>
{
_asyncShowWaitHandle.WaitOne();
}).ContinueWith(t =>
{
_asyncShowOpenedEventHandler = null;
_asyncShowClosingEventHandler = null;
return(_closeDialogExecutionParameter);
});
return(task);
}
public async Task ShowAsync(object o, string dialogID, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
var control = new OperationProcessingControl();
control.DataContext = o;
await DialogHost.Show(control, dialogID, openedEventHandler, closingEventHandler);
}
internal async Task <object> ShowInternal(object content, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
if (IsOpen)
{
throw new InvalidOperationException("对话框已经被打开。");
}
AssertTargetableContent();
DialogContent = content;
_asyncShowOpenedEventHandler = openedEventHandler;
_asyncShowClosingEventHandler = closingEventHandler;
SetCurrentValue(IsOpenProperty, true);
var task = new Task(() =>
{
_asyncShowWaitHandle.WaitOne();
});
task.Start();
await task;
_asyncShowOpenedEventHandler = null;
_asyncShowClosingEventHandler = null;
return(_closeDialogExecutionParameter);
}
private void OpenDialogHandler(object sender, ExecutedRoutedEventArgs executedRoutedEventArgs)
{
if (executedRoutedEventArgs.Handled)
{
return;
}
var dependencyObject = executedRoutedEventArgs.OriginalSource as DependencyObject;
if (dependencyObject != null)
{
_attachedDialogOpenedEventHandler = GetDialogOpenedAttached(dependencyObject);
_attachedDialogClosingEventHandler = GetDialogClosingAttached(dependencyObject);
}
if (executedRoutedEventArgs.Parameter != null)
{
AssertTargetableContent();
DialogContent = executedRoutedEventArgs.Parameter;
}
SetCurrentValue(IsOpenProperty, true);
executedRoutedEventArgs.Handled = true;
}
public override Task <bool> ShowDialog(DialogOpenedEventHandler openedEventHandler = null, DialogClosingEventHandler closingEventHandler = null)
{
var dialog = GetDialogWindow();
dialog.ShowDialog();
return(Task.FromResult((dialog.DataContext as BaseDialogOperation).Result));
}
public static Task <object> Show(object content, DialogOpenedEventHandler openedEventHandler = null, DialogClosingEventHandler closingEventHandler = null)
{
return(Application.Current.Dispatcher.Invoke(() => {
CloseDialog();
return DialogHost.Show(content, openedEventHandler, closingEventHandler);
}));
}
public void OpenDialog(INotifyPropertyChanged viewModel, DialogOpenedEventHandler dialogOpenedEventHandler)
{
DialogHost.Show(viewModel, (object source, MaterialDesignThemes.Wpf.DialogOpenedEventArgs args) =>
{
dialogOpenedEventHandler?.Invoke(source, new DialogOpenedEventArgs(new MDSession(args.Session)));
});
}
internal async Task <object> ShowInternal(object content, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
if (IsOpen)
{
throw new InvalidOperationException("DialogHost is already open.");
}
_closeDialogExecutionParameter = null; // fix to prevent dialog return the previous value when unloaded
AssertTargetableContent();
DialogContent = content;
_asyncShowOpenedEventHandler = openedEventHandler;
_asyncShowClosingEventHandler = closingEventHandler;
SetCurrentValue(IsOpenProperty, true);
var task = new Task(() =>
{
_asyncShowWaitHandle.WaitOne();
});
task.Start();
await task;
_asyncShowOpenedEventHandler = null;
_asyncShowClosingEventHandler = null;
return(_closeDialogExecutionParameter);
}
private async void ShowFreshDialog(object parameter)
{
DialogOpenedEventHandler openedEventHandler = null;
DialogClosingEventHandler closingEventHandler = null;
Console.WriteLine("Parameter:", parameter);
await DialogHost.Show(new FreshController(), openedEventHandler, closingEventHandler); //TODO add CancellationToken
}
public static async Task <SaveFileDialogResult> ShowDialogAsync(string dialogHostName, double?width = null, double?height = null,
string currentDirectory = null, string filename = null,
bool showHiddenFilesAndDirectories = false, bool showSystemFilesAndDirectories = false,
DialogOpenedEventHandler openedHandler = null, DialogClosingEventHandler closingHandler = null)
{
SaveFileDialog dialog = InitDialog(width, height, currentDirectory, filename, null, -1, showHiddenFilesAndDirectories, showSystemFilesAndDirectories);
return(await DialogHost.Show(dialog, dialogHostName, openedHandler, closingHandler) as SaveFileDialogResult);
}
public static async Task <OpenDirectoryDialogResult> ShowDialogAsync(DialogHost dialogHost, double?width = null, double?height = null,
string currentDirectory = null,
bool showHiddenFilesAndDirectories = false, bool showSystemFilesAndDirectories = false,
DialogOpenedEventHandler openedHandler = null, DialogClosingEventHandler closingHandler = null)
{
OpenDirectoryDialog dialog = InitDialog(width, height, currentDirectory, showHiddenFilesAndDirectories, showSystemFilesAndDirectories);
return(await dialogHost.ShowDialog(dialog, openedHandler, closingHandler) as OpenDirectoryDialogResult);
}
private static async Task ShowDialogExtended(object content, object dialogIdentifier,
DialogOpenedEventHandler openedEventHandler,
DialogClosingEventHandler closingEventHandler)
{
var result = await DialogHost.Show(content, dialogIdentifier, openedEventHandler,
closingEventHandler);
_logger.Debug(
$"Dialog was closed, the CommandParameter used to close it was: {result ?? "NULL"}"
);
}
public Task ShowAsync(object o, string dialogID, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
PassedObject = o;
DialogID = dialogID;
NumberOfCalls++;
var viewModel = o as ProgressControlViewModel;
viewModel.OnCompleted += ViewModel_OnCompleted;
openedEventHandler.Invoke(this, null);
waitHandle.WaitOne();
return(Task.CompletedTask);
}
/// <summary>
/// Displays a requested view.
/// </summary>
/// <param name="message"></param>
public Task <object> OpenDialogAsync <TUserControl, TViewModel>
(
string dialogIdentifier,
DialogOpenedEventHandler openedEventHandler,
DialogClosingEventHandler closingEventHandler,
TViewModel viewModel = default(TViewModel),
object parameter = null
)
where TUserControl : UserControl, new()
where TViewModel : IViewModel, new()
{
var view = CreateUserControl <TUserControl, TViewModel>(viewModel, parameter);
return(DialogHost.Show(view, dialogIdentifier, openedEventHandler, closingEventHandler));
}
private void OpenDialogHandler(object sender, ExecutedRoutedEventArgs executedRoutedEventArgs)
{
if (executedRoutedEventArgs.Handled)
{
return;
}
var dependencyObject = executedRoutedEventArgs.OriginalSource as DependencyObject;
if (dependencyObject != null)
{
_attachedDialogOpenedEventHandler = GetDialogOpenedAttached(dependencyObject);
_attachedDialogClosingEventHandler = GetDialogClosingAttached(dependencyObject);
}
if (executedRoutedEventArgs.Parameter != null)
{
AssertTargetableContent();
if (_popupContentControl != null)
{
switch (OpenDialogCommandDataContextSource)
{
case DialogHostOpenDialogCommandDataContextSource.SenderElement:
_popupContentControl.DataContext =
(executedRoutedEventArgs.Parameter as FrameworkElement)?.DataContext;
break;
case DialogHostOpenDialogCommandDataContextSource.DialogHostInstance:
_popupContentControl.DataContext = DataContext;
break;
case DialogHostOpenDialogCommandDataContextSource.None:
_popupContentControl.DataContext = null;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
DialogContent = executedRoutedEventArgs.Parameter;
}
SetCurrentValue(IsOpenProperty, true);
executedRoutedEventArgs.Handled = true;
}
public static async Task ShowDialogExtended(object content, object dialogIdentifier,
DialogOpenedEventHandler openedEventHandler,
DialogClosingEventHandler closingEventHandler)
{
content.ThrowIfNull(nameof(content));
dialogIdentifier.ThrowIfNull(nameof(dialogIdentifier));
openedEventHandler.ThrowIfNull(nameof(openedEventHandler));
closingEventHandler.ThrowIfNull(nameof(closingEventHandler));
object result = await DialogHost.Show(
content, dialogIdentifier, openedEventHandler, closingEventHandler
);
_logger.Debug(
$"Dialog was closed, the CommandParameter used to close it was: {result ?? "NULL"}."
);
}
private Task <object> ShowDialog(object content, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler dialogClosingEventHandler)
{
HashSet <DialogHost> instances = (HashSet <DialogHost>)dialogInstancesField.GetValue(null);
if (instances != null)
{
if (instances.Count == 0)
{
throw new InvalidOperationException("No loaded DialogHost instances.");
}
DialogHost host = instances.First();
if (host.IsOpen)
{
host.IsOpen = false;
}
return(host.ShowDialog(content, openedEventHandler, dialogClosingEventHandler));
}
return(DialogHost.Show(content, openedEventHandler, dialogClosingEventHandler));
}
public async Task ShowDialogAsync(DialogScreen dialogScreen)
{
// Get the view that renders this viewmodel
var view = _viewManager.CreateAndBindViewForModelIfNecessary(dialogScreen);
// Set up event routing that will close the view when called from viewmodel
DialogOpenedEventHandler onDialogOpened = (sender, e) =>
{
// Delegate to close the dialog and unregister event handler
void OnScreenClosed(object o, CloseEventArgs args)
{
e.Session.Close();
dialogScreen.Closed -= OnScreenClosed;
}
dialogScreen.Closed += OnScreenClosed;
};
// Show view
await DialogHost.Show(view, onDialogOpened);
}
private DialogOpenedEventHandler GetDialogOpenedEventHandler(IHostDialogAware viewModel,
IDialogParameters parameters)
{
if (parameters == null)
{
parameters = new DialogParameters();
}
DialogOpenedEventHandler eventHandler =
(sender, eventArgs) =>
{
var _content = eventArgs.Session.Content;
if (viewModel is IHostDialogAware aware)
{
aware.OnDialogOpened(parameters);
}
eventArgs.Session.UpdateContent(_content);
};
return(eventHandler);
}
public async Task <IDialogResult> ShowDialog(string name, IDialogParameters parameters = null, string IdentifierName = "Root")
{
if (parameters == null)
{
parameters = new DialogParameters();
}
var content = _containerExtension.Resolve <object>(name);
if (!(content is FrameworkElement dialogContent))
{
throw new NullReferenceException("A dialog's content must be a FrameworkElement");
}
if (dialogContent is FrameworkElement view && view.DataContext is null && ViewModelLocator.GetAutoWireViewModel(view) is null)
{
ViewModelLocator.SetAutoWireViewModel(view, true);
}
if (!(dialogContent.DataContext is IDialogHostAware viewModel))
{
throw new NullReferenceException("A dialog's ViewModel must implement the IDialogAware interface");
}
viewModel.IdentifierName = IdentifierName;
DialogOpenedEventHandler eventHandler = async
(sender, eventArgs) =>
{
var content = eventArgs.Session.Content;
eventArgs.Session.UpdateContent(new ProgressDialog());
if (viewModel is IDialogHostAware aware)
{
await aware.OnDialogOpenedAsync(parameters);
}
eventArgs.Session.UpdateContent(content);
};
return((IDialogResult)await DialogHost.Show(dialogContent, viewModel.IdentifierName, eventHandler));
}
public Task <object> Show(object content, EventHandler <DialogOpenedEventArgs> openedArgs, EventHandler <DialogClosingEventArgs> closingArgs)
{
DialogOpenedEventHandler openedEventHandler = new DialogOpenedEventHandler((s, args) => {
DialogOpenedEventArgs extArgs = new DialogOpenedEventArgs();
openedArgs(s, extArgs);
if (extArgs.ShouldClose)
{
args.Session.Close();
}
});
DialogClosingEventHandler dialogClosingEventHandler = new DialogClosingEventHandler((s, args) => {
DialogClosingEventArgs extArgs = new DialogClosingEventArgs(args.Parameter);
closingArgs(s, extArgs);
if (extArgs.IsCancelled)
{
args.Cancel();
}
});
return(ShowDialog(content, openedEventHandler, dialogClosingEventHandler));
}
private void OpenDialogHandler(object sender, ExecutedRoutedEventArgs executedRoutedEventArgs)
{
if (executedRoutedEventArgs.Handled)
{
return;
}
var dependencyObject = executedRoutedEventArgs.OriginalSource as DependencyObject;
if (dependencyObject != null)
{
_attachedDialogOpenedEventHandler = GetDialogOpenedAttached(dependencyObject);
_attachedDialogClosingEventHandler = GetDialogClosingAttached(dependencyObject);
}
if (executedRoutedEventArgs.Parameter != null)
{
AssertTargetableContent();
//TODO enhancement: make the following configurable, so that the data context can be pulled from the dialog host if desired.
// (leave the current behaviour as the default; most developers will find this logical, as the data context will "inherit" from button containing the content)
var contentElement = executedRoutedEventArgs.Parameter as FrameworkElement;
var senderElement = executedRoutedEventArgs.OriginalSource as FrameworkElement;
if (contentElement != null && senderElement != null && contentElement.DataContext == null && BindingOperations.GetBindingExpression(contentElement, DataContextProperty) == null)
{
DialogContent = executedRoutedEventArgs.Parameter;
contentElement.SetCurrentValue(DataContextProperty, senderElement.DataContext);
}
else
{
DialogContent = executedRoutedEventArgs.Parameter;
}
}
SetCurrentValue(IsOpenProperty, true);
executedRoutedEventArgs.Handled = true;
}
/// <summary>
/// Shows a modal dialog. To use, a <see cref="DialogHost"/> instance must be in a visual tree (typically this may be specified towards the root of a Window's XAML).
/// </summary>
/// <param name="content">Content to show (can be a control or view model).</param>
/// <param name="openedEventHandler">Allows access to opened event which would otherwise have been subscribed to on a instance.</param>
/// <returns>Task result is the parameter used to close the dialog, typically what is passed to the <see cref="CloseDialogCommand"/> command.</returns>
public static async Task <object> Show(object content, DialogOpenedEventHandler openedEventHandler)
{
return(await Show(content, null, openedEventHandler, null));
}
public static void SetDialogOpenedAttached(DependencyObject element, DialogOpenedEventHandler value)
{
element.SetValue(DialogOpenedAttachedProperty, value);
}
/// <summary>
/// Shows a modal dialog. To use, a <see cref="DialogHost"/> instance must be in a visual tree (typically this may be specified towards the root of a Window's XAML).
/// </summary>
/// <param name="content">Content to show (can be a control or view model).</param>
/// <param name="dialogIndetifier"><see cref="Identifier"/> of the instance where the dialog should be shown. Typically this will match an identifer set in XAML. <c>null</c> is allowed.</param>
/// <param name="openedEventHandler">Allows access to opened event which would otherwise have been subscribed to on a instance.</param>
/// <param name="closingEventHandler">Allows access to closing event which would otherwise have been subscribed to on a instance.</param>
/// <returns>Task result is the parameter used to close the dialog, typically what is passed to the <see cref="CloseDialogCommand"/> command.</returns>
public static async Task <object> Show(object content, object dialogIndetifier, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
if (LoadedInstances.Count == 0)
{
throw new InvalidOperationException("No loaded DialogHost instances.");
}
LoadedInstances.First().Dispatcher.VerifyAccess();
var targets = LoadedInstances.Where(dh => Equals(dh.Identifier, dialogIndetifier)).ToList();
if (targets.Count == 0)
{
throw new InvalidOperationException("No loaded DialogHost matches identifier.");
}
if (targets.Count > 1)
{
throw new InvalidOperationException("Multiple viable DialogHosts. Specify a unique identifier.");
}
if (targets[0].IsOpen)
{
throw new InvalidOperationException("DialogHost is already open.");
}
targets[0].AssertTargetableContent();
targets[0].DialogContent = content;
targets[0]._asyncShowOpenedEventHandler = openedEventHandler;
targets[0]._asyncShowClosingEventHandler = closingEventHandler;
targets[0].SetCurrentValue(IsOpenProperty, true);
var task = new Task(() =>
{
targets[0]._asyncShowWaitHandle.WaitOne();
});
task.Start();
await task;
targets[0]._asyncShowOpenedEventHandler = null;
targets[0]._asyncShowClosingEventHandler = null;
return(targets[0]._closeDialogExecutionParameter);
}
/// <summary>
/// Shows a modal dialog. To use, a <see cref="DialogHost"/> instance must be in a visual tree (typically this may be specified towards the root of a Window's XAML).
/// </summary>
/// <param name="content">Content to show (can be a control or view model).</param>
/// <param name="openedEventHandler">Allows access to opened event which would otherwise have been subscribed to on a instance.</param>
/// <param name="closingEventHandler">Allows access to closing event which would otherwise have been subscribed to on a instance.</param>
/// <returns>Task result is the parameter used to close the dialog, typically what is passed to the <see cref="CloseDialogCommand"/> command.</returns>
public static async Task<object> Show(object content, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
return await Show(content, null, openedEventHandler, closingEventHandler);
}
private void OpenDialogHandler(object sender, ExecutedRoutedEventArgs executedRoutedEventArgs)
{
if (executedRoutedEventArgs.Handled) return;
var dependencyObject = executedRoutedEventArgs.OriginalSource as DependencyObject;
if (dependencyObject != null)
{
_attachedDialogOpenedEventHandler = GetDialogOpenedAttached(dependencyObject);
_attachedDialogClosingEventHandler = GetDialogClosingAttached(dependencyObject);
}
if (executedRoutedEventArgs.Parameter != null)
{
AssertTargetableContent();
//TODO enhancement: make the following configurable, so that the data context can be pulled from the dialog host if desired.
// (leave the current behaviour as the default; most developers will find this logical, as the data context will "inherit" from button containing the content)
var contentElement = executedRoutedEventArgs.Parameter as FrameworkElement;
var senderElement = executedRoutedEventArgs.OriginalSource as FrameworkElement;
if (contentElement != null && senderElement != null && contentElement.DataContext == null && BindingOperations.GetBindingExpression(contentElement, DataContextProperty) == null)
{
DialogContent = executedRoutedEventArgs.Parameter;
contentElement.SetCurrentValue(DataContextProperty, senderElement.DataContext);
}
else
DialogContent = executedRoutedEventArgs.Parameter;
}
SetCurrentValue(IsOpenProperty, true);
executedRoutedEventArgs.Handled = true;
}
public static void SetDialogOpenedAttached(DependencyObject element, DialogOpenedEventHandler value)
{
element.SetValue(DialogOpenedAttachedProperty, value);
}
/// <summary>
/// Shows a modal dialog. To use, a <see cref="DialogHost"/> instance must be in a visual tree (typically this may be specified towards the root of a Window's XAML).
/// </summary>
/// <param name="content">Content to show (can be a control or view model).</param>
/// <param name="dialogIndetifier"><see cref="Identifier"/> of the instance where the dialog should be shown. Typically this will match an identifer set in XAML. <c>null</c> is allowed.</param>
/// <param name="openedEventHandler">Allows access to opened event which would otherwise have been subscribed to on a instance.</param>
/// <param name="closingEventHandler">Allows access to closing event which would otherwise have been subscribed to on a instance.</param>
/// <returns>Task result is the parameter used to close the dialog, typically what is passed to the <see cref="CloseDialogCommand"/> command.</returns>
public static async Task<object> Show(object content, object dialogIndetifier, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
if (content == null) throw new ArgumentNullException(nameof(content));
if (LoadedInstances.Count == 0)
throw new InvalidOperationException("No loaded DialogHost instances.");
LoadedInstances.First().Dispatcher.VerifyAccess();
var targets = LoadedInstances.Where(dh => Equals(dh.Identifier, dialogIndetifier)).ToList();
if (targets.Count == 0)
throw new InvalidOperationException("No loaded DialogHost matches identifier.");
if (targets.Count > 1)
throw new InvalidOperationException("Multiple viable DialogHosts. Specify a unique identifier.");
if (targets[0].IsOpen)
throw new InvalidOperationException("DialogHost is already open.");
targets[0].AssertTargetableContent();
targets[0].DialogContent = content;
targets[0]._asyncShowOpenedEventHandler = openedEventHandler;
targets[0]._asyncShowClosingEventHandler = closingEventHandler;
targets[0].SetCurrentValue(IsOpenProperty, true);
var task = new Task(() =>
{
targets[0]._asyncShowWaitHandle.WaitOne();
});
task.Start();
await task;
targets[0]._asyncShowOpenedEventHandler = null;
targets[0]._asyncShowClosingEventHandler = null;
return targets[0]._closeDialogExecutionParameter;
}
/// <summary>
/// Shows a modal dialog. To use, a <see cref="DialogHost"/> instance must be in a visual tree (typically this may be specified towards the root of a Window's XAML).
/// </summary>
/// <param name="content">Content to show (can be a control or view model).</param>
/// <param name="dialogIndetifier"><see cref="Identifier"/> of the instance where the dialog should be shown. Typically this will match an identifer set in XAML. <c>null</c> is allowed.</param>
/// <param name="openedEventHandler">Allows access to opened event which would otherwise have been subscribed to on a instance.</param>
/// <returns>Task result is the parameter used to close the dialog, typically what is passed to the <see cref="CloseDialogCommand"/> command.</returns>
public static Task<object> Show(object content, object dialogIndetifier, DialogOpenedEventHandler openedEventHandler)
{
return Show(content, dialogIndetifier, openedEventHandler, null);
}
private void OpenDialogHandler(object sender, ExecutedRoutedEventArgs executedRoutedEventArgs)
{
if (executedRoutedEventArgs.Handled) return;
var dependencyObject = executedRoutedEventArgs.OriginalSource as DependencyObject;
if (dependencyObject != null)
{
_attachedDialogOpenedEventHandler = GetDialogOpenedAttached(dependencyObject);
_attachedDialogClosingEventHandler = GetDialogClosingAttached(dependencyObject);
}
if (executedRoutedEventArgs.Parameter != null)
{
AssertTargetableContent();
DialogContent = executedRoutedEventArgs.Parameter;
}
SetCurrentValue(IsOpenProperty, true);
executedRoutedEventArgs.Handled = true;
}
/// <summary>
/// Shows a dialog using the first found <see cref="DialogHost"/> in a given <see cref="Window"/>.
/// </summary>
/// <param name="window">Window on which the modal dialog should be displayed. Must contain a <see cref="DialogHost"/>.</param>
/// <param name="content">Content to show (can be a control or view model).</param>
/// <param name="openedEventHandler">Allows access to opened event which would otherwise have been subscribed to on a instance.</param>
/// <param name="closingEventHandler">Allows access to closing event which would otherwise have been subscribed to on a instance.</param>
/// <exception cref="InvalidOperationException">
/// Thrown is a <see cref="DialogHost"/> is not found when conducting a depth first traversal of visual tree.
/// </exception>
/// <remarks>
/// As a depth first traversal of the window's visual tree is performed, it is not safe to use this method in a situtation where a screen has multiple <see cref="DialogHost"/>s.
/// </remarks>
/// <returns></returns>
public static async Task<object> ShowDialog(this Window window, object content, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
return await GetFirstDialogHost(window).ShowInternal(content, openedEventHandler, closingEventHandler);
}
/// <summary>
/// Shows a dialog using the parent/ancestor <see cref="DialogHost"/> of the a given <see cref="DependencyObject"/>.
/// </summary>
/// <param name="childDependencyObject">Dependency object which should be a visual child of a <see cref="DialogHost"/>, where the dialog will be shown.</param>
/// <param name="content">Content to show (can be a control or view model).</param>
/// <param name="openedEventHandler">Allows access to opened event which would otherwise have been subscribed to on a instance.</param>
/// <param name="closingEventHandler">Allows access to closing event which would otherwise have been subscribed to on a instance.</param>
/// <exception cref="InvalidOperationException">
/// Thrown is a <see cref="DialogHost"/> is not found when conducting a depth first traversal of visual tree.
/// </exception>
/// <returns></returns>
public static async Task<object> ShowDialog(this DependencyObject childDependencyObject, object content, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
return await GetOwningDialogHost(childDependencyObject).ShowInternal(content, openedEventHandler, closingEventHandler);
}
private void OpenDialogHandler(object sender, ExecutedRoutedEventArgs executedRoutedEventArgs)
{
if (executedRoutedEventArgs.Handled) return;
var dependencyObject = executedRoutedEventArgs.OriginalSource as DependencyObject;
if (dependencyObject != null)
{
_attachedDialogOpenedEventHandler = GetDialogOpenedAttached(dependencyObject);
_attachedDialogClosingEventHandler = GetDialogClosingAttached(dependencyObject);
}
if (executedRoutedEventArgs.Parameter != null)
{
AssertTargetableContent();
if (_popupContentControl != null)
{
switch (OpenDialogCommandDataContextSource)
{
case DialogHostOpenDialogCommandDataContextSource.SenderElement:
_popupContentControl.DataContext =
(executedRoutedEventArgs.Parameter as FrameworkElement)?.DataContext;
break;
case DialogHostOpenDialogCommandDataContextSource.DialogHostInstance:
_popupContentControl.DataContext = DataContext;
break;
case DialogHostOpenDialogCommandDataContextSource.None:
_popupContentControl.DataContext = null;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
DialogContent = executedRoutedEventArgs.Parameter;
}
SetCurrentValue(IsOpenProperty, true);
executedRoutedEventArgs.Handled = true;
}
public static Task <object> PopupDialog(this UserControl con, object dialogIdentifier = null, DialogOpenedEventHandler openedEventHandler = null, DialogClosingEventHandler closingEventHandler = null) //必须为public static 类型，且参数使用this关键字
{
return(Application.Current.Dispatcher.Invoke <Task <object> >(() =>
{
return DialogHost.Show(con, dialogIdentifier, openedEventHandler, closingEventHandler);
}));
}
internal async Task<object> ShowInternal(object content, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
if (IsOpen)
throw new InvalidOperationException("DialogHost is already open.");
AssertTargetableContent();
DialogContent = content;
_asyncShowOpenedEventHandler = openedEventHandler;
_asyncShowClosingEventHandler = closingEventHandler;
SetCurrentValue(IsOpenProperty, true);
var task = new Task(() =>
{
_asyncShowWaitHandle.WaitOne();
});
task.Start();
await task;
_asyncShowOpenedEventHandler = null;
_asyncShowClosingEventHandler = null;
return _closeDialogExecutionParameter;
}
public static void CloseDialog(this UserControl con, object dialogIdentifier = null, DialogOpenedEventHandler openedEventHandler = null, DialogClosingEventHandler closingEventHandler = null) //必须为public static 类型，且参数使用this关键字
{
Application.Current.Dispatcher.Invoke(() =>
{
DialogHost.CloseDialogCommand.Execute(con, con);
//return DialogHost.close(con, dialogIdentifier, openedEventHandler, closingEventHandler);
});
}
/// <summary>
/// Shows a modal dialog. To use, a <see cref="DialogHost"/> instance must be in a visual tree (typically this may be specified towards the root of a Window's XAML).
/// </summary>
/// <param name="content">Content to show (can be a control or view model).</param>
/// <param name="dialogIdentifier"><see cref="Identifier"/> of the instance where the dialog should be shown. Typically this will match an identifer set in XAML. <c>null</c> is allowed.</param>
/// <param name="openedEventHandler">Allows access to opened event which would otherwise have been subscribed to on a instance.</param>
/// <param name="closingEventHandler">Allows access to closing event which would otherwise have been subscribed to on a instance.</param>
/// <returns>Task result is the parameter used to close the dialog, typically what is passed to the <see cref="CloseDialogCommand"/> command.</returns>
public static async Task<object> Show(object content, object dialogIdentifier, DialogOpenedEventHandler openedEventHandler, DialogClosingEventHandler closingEventHandler)
{
if (content == null) throw new ArgumentNullException(nameof(content));
if (LoadedInstances.Count == 0)
throw new InvalidOperationException("No loaded DialogHost instances.");
LoadedInstances.First().Dispatcher.VerifyAccess();
var targets = LoadedInstances.Where(dh => Equals(dh.Identifier, dialogIdentifier)).ToList();
if (targets.Count == 0)
throw new InvalidOperationException("No loaded DialogHost have an Identifier property matching dialogIndetifier argument.");
if (targets.Count > 1)
throw new InvalidOperationException("Multiple viable DialogHosts. Specify a unique Identifier on each DialogHost, especially where multiple Windows are a concern.");
return await targets[0].ShowInternal(content, openedEventHandler, closingEventHandler);
}
