IsDefault on button makes it click itself on close

[tznind]

Describe the bug
When a View has 2 Button (A and B). Both have Accepting handler. One of which IsDefault then the default one is always fired even when clicking on the other button.

To Reproduce

Application.Init ();

Window w = new Window () { Width = Dim.Fill (), Height = Dim.Fill () };

var btn1 = new Button ()
{
    Text = "A",
    IsDefault = true,
};
btn1.Accepting += (s, e) => {
                      Debug.WriteLine ("A pressed");
                      Application.RequestStop ();
                  };

var btn2 = new Button ()
{
    X = Pos.Right (btn1),
    Text = "B"
};
btn2.Accepting += (s, e) =>
                  {
                      Debug.WriteLine ("B pressed");
                      Application.RequestStop ();
                  };

w.Add (btn1);
w.Add (btn2);

Application.Run (w);
w.Dispose ();
Application.Shutdown ();

return 0;

When you click A you see

"Pressed A"

When you click B you see

"Pressed B"
"Pressed A"

Expected behavior
Button should not click itself!

** Workaround **
As a workaround you can have all the buttons that are not IsDefault call e.Cancel on the accepting event.

btn2.Accepting += (s, e) =>
                  {
                      Debug.WriteLine ("B pressed");
+                    e.Cancel = true;
                      Application.RequestStop ();
                  };

[tig]

Good catch. I'll get to it asap. A unit test would be goovy.

[tznind]

Good catch. I'll get to it asap. A unit test would be goovy.

Here is a unit test. And in fact it doesn't even need RequestClose, if you click a Button then any other one that IsDefault will also get automatically clicked.

 [SetupFakeDriver]
 [Fact]
 public void TestButtonIsDefault_DoesNotAutoFire()
 {
     // When we have 2 buttons, one of which is default
     bool clickA = false;
     bool clickB = false;
     var w = new Window ()
     {
         BorderStyle = LineStyle.None,
         Width = 10,
         Height = 10
     };


     var btn1 = new Button ()
     {
         Width = 3,
         IsDefault = true
     };
     btn1.Accepting += (s, e) => { clickA = true; };

     var btn2 = new Button ()
     {
         Width = 3,
         X = Pos.Right (btn1)
     };

     btn2.Accepting += (s, e) => { clickB = true; };
     w.Add (btn1, btn2);

     w.LayoutSubviews ();

     Application.Begin (w);
     Assert.Same (Application.Top,w);

     // Click button 2
     btn2.NewMouseEvent (
                      new MouseEventArgs ()
                      {
                          Flags = MouseFlags.Button1Clicked
                      });

     // Should only cause button 2 to be activated
     Assert.True (clickB);

     // Button 1 should remain unactivated
     Assert.False (clickA);
 }

[tig]

Aaaaactually....

See: https://gui-cs.github.io/Terminal.GuiV2Docs/api/Terminal.Gui.View.RaiseAccepting.html

This is the documented behavior:

If a peer-View raises the Accepting event and the event is not cancelled, the Accept will be invoked on the first Button in the SuperView that has IsDefault set to true.

And, I think it makes total sense.

Accepting is defined as

Cancelable event raised when the user is accepting the state of the View and the Accept has been invoked. Set CommandEventArgs.Cancel to cancel the event.

If a View raises Accepting and nobody cancels it, then it's like it didn't happen.

The below is not actually a workaround, but correct:

btn2.Accepting += (s, e) =>
                  {
                      Debug.WriteLine ("B pressed");
+                    e.Cancel = true;
                      Application.RequestStop ();
                  };

Now, perhaps it was a mistake to rename Handled -> Cancel, as in this context what I say above makes even more sense.

Here's your unit test, updated:

 // See https://github.com/gui-cs/Terminal.Gui/issues/3913
 [Fact]
 public void Button_IsDefault_Raises_Accepted_Correctly ()
 {
     int A_AcceptedCount = 0;
     bool A_CancelAccepting = false;

     int B_AcceptedCount = 0;
     bool B_CancelAccepting = false;

     var w = new Window ()
     {
         BorderStyle = LineStyle.None,
         Width = 10,
         Height = 10
     };

     var btnA = new Button ()
     {
         Width = 3,
         IsDefault = true
     };
     btnA.Accepting += (s, e) =>
                       {
                           A_AcceptedCount++;
                           e.Cancel = A_CancelAccepting;
                       };

     var btnB = new Button ()
     {
         Width = 3,
         X = Pos.Right (btnA)
     };

     btnB.Accepting += (s, e) =>
                       {
                           B_AcceptedCount++;
                           e.Cancel = B_CancelAccepting;
                       };
     w.Add (btnA, btnB);

     w.LayoutSubviews ();

     Application.Begin (w);
     Assert.Same (Application.Top, w);

     // Click button 2
     var btn2Frame = btnB.FrameToScreen ();

     Application.RaiseMouseEvent (
                      new MouseEventArgs ()
                      {
                          ScreenPosition = btn2Frame.Location,
                          Flags = MouseFlags.Button1Clicked
                      });

     // Button A should have been accepted because B didn't cancel and A IsDefault
     Assert.Equal (1, A_AcceptedCount);
     Assert.Equal (1, B_AcceptedCount);

     B_CancelAccepting = true;
     Application.RaiseMouseEvent (
                                  new MouseEventArgs ()
                                  {
                                      ScreenPosition = btn2Frame.Location,
                                      Flags = MouseFlags.Button1Clicked
                                  });

     // Button A (IsDefault) should NOT have been accepted because B canceled
     Assert.Equal (1, A_AcceptedCount);
     Assert.Equal (2, B_AcceptedCount);
 }

[tig]

Closing as "Won't fix. By Design."