获取Window ShowDialog取消和关闭之间的区别

Question

In our app we use WPF and Caliburn Micro. We use a custom WindowManager:

public class OurWindowManager : Caliburn.Micro.WindowManager
{
    protected override Window EnsureWindow(object model, object view, bool isDialog)
    {
        var window = base.EnsureWindow(model, view, isDialog);
        if (isDialog) window.ResizeMode = ResizeMode.NoResize;
        window.Icon = new BitmapImage(new Uri("pack://application:,,,/NWB.ico"));

        // TODO: Change to dynamic minWidth/minHeight based on window
        window.MinWidth = 600;

        new WindowSettingsBehavior().Attach(window);

        return window;
    }
}

In our code we mostly use this WindowManager like so:

public void SomeMethod()
{
    var result = _windowManager.ShowDialog(new ConfirmDialogViewModel("some title",
        "some text"));
    if(result == true){ // if OK is pressed
        // do something on OK
    }
    // do nothing
}

In one of my recent methods I want to do the following (in semi pseudo-code):

public void SomeOtherMethod()
{
    _windowManager.ShowDialog(new ConfirmDialogViewModel("some title", "some text"));
    //if window is closed without pressing any of the buttons
        return; // do nothing

    //if OK is pressed {
        // do something on OK
    }
    // if Cancel is pressed: do something else
}

Unfortunately, ShowDialog also returns false if the Window is closed (even though the ShowDialog returns a Nullable bool ( bool? )).

So, what I did so far is just completely remove the Close Button by making a new Window-Behavior , and I've added it to the OurWindowManager class inside the if(isDialog) :

if (isDialog)
{
    window.ResizeMode = ResizeMode.NoResize;
    new WindowHideBarBehavior().Attach(window);
}

This works, and I now got a Window with just a title, and without a Close (X) button. Unfortunately, the window can still be closed with Alt+F4 and such. I thought about catching Alt+F4 and cancel the closing, but since Alt+F4 is standard Window behavior, I don't think users will appreciate it a lot and I find it a bit unintuitive for the users to disable it..

So, my question: How can I accomplish the pseudo-code in SomeOtherMethod mentioned above. Is there a way to get the difference between closing a Dialog or canceling a Dialog. (NOTE: As mentioned above, keep in mind we use Caliburn.Micro.WindowManager , not the default C# WPF one. Don't know if there are a lot of differences, but I guess there are at least some.)

---

EDIT:

I also know I can catch the closing event and cancel the closing:

window.Closing -= DisableDialogClosing;
if (isDialog)
{
    window.ResizeMode = ResizeMode.NoResize;
    new WindowHideBarBehavior().Attach(window);
    window.Closing += DisableDialogClosing;
}

...

private static void DisableDialogClosing(object sender, CancelEventArgs e)
{
    e.Cancel = true;
}

But then it also cancels the closing when I want it to close (for example when the Cancel/OK button is pressed). Maybe I can add some kind of Property-flag to this overridden Closing-EventHandler, but perhaps you guys/girls have other suggestions to accomplish the same results.

Answer 1

You can fulfil your requirements if you just implement your own dialog Window by extending the Window class. From inside your custom Window , you can handle the Closed event and set the Window.DialogResult property to null in that case. For the normal Ok and Cancel states, you can simply attach Click handlers to those Button s and set the Window.DialogResult property to true and false accordingly.

private void CustomDialogWindow_Close(object sender, RoutedEventArgs e)
{
    DialogResult = null;
}

private void OkButton_Click(object sender, RoutedEventArgs e)
{
    DialogResult = true;
}

private void CancelButton_Click(object sender, RoutedEventArgs e)
{
    DialogResult = false;
}

You could then check for the Window closed state like this:

if (CustomDialogWindow.DialogResult == null) DoSomethingUponDialogWindowClose();

You can find further helpful information in the following pages on MSDN:

Dialog Boxes Overview
Window.DialogResult Property

Answer 2

After @Sinatr 's suggestion I've added a ClosedBy property to my ConfirmDialogViewModel:

(before):

public sealed class ConfirmDialogViewModel : Screen
{
    public ConfirmDialogViewModel(string title, string message)
    {
        DisplayName = title;
        Message = message;
    }

    public string Message { get; set; }

    public void Ok()
    {
        TryClose(true);
    }

    public void Cancel()
    {
        TryClose(false);
    }
}

(after):

public sealed class ConfirmDialogViewModel : Screen
{
    public ClosedBy CloseReason { get; private set; }

    public ConfirmDialogViewModel(string title, string message)
    {
        DisplayName = title;
        Message = message;
        CloseReason = ClosedBy.Other;
    }

    public string Message { get; set; }

    public void Ok()
    {
        CloseReason = ClosedBy.Ok;
        TryClose(true);
    }

    public void Cancel()
    {
        CloseReason = ClosedBy.Cancel;
        TryClose(false);
    }
}

public enum ClosedBy
{
    Other,
    Ok,
    Cancel
}

And I now use it like so:

public void SomeOtherMethod()
{
    var confirmDialog = new ConfirmDialogViewModel("some title", "some text");
    var result = _windowManager.ShowDialog(confirmDialog);
    if(result == null || confirmDialog.CloseReason == ClosedBy.Other) return;

    if(result == true && confirmDialog.CloseReason == ClosedBy.Ok){
        // Do something on OK
    }
    // Do something on cancel
}

I still kept the behavior to remove the close button, and also added window.ShowInTaskbar = false; to the OurWindowManager inside the if(isDialog) .