gui-cs.Terminal.Gui/Terminal.Gui/Application/Application.Mouse.cs

#nullable enable
<<<<<<< Updated upstream
=======
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.VisualBasic.Syntax;

>>>>>>> Stashed changes
namespace Terminal.Gui;

public static partial class Application // Mouse handling
{
    #region Mouse handling

    /// <summary>Disable or enable the mouse. The mouse is enabled by default.</summary>
    [SerializableConfigurationProperty (Scope = typeof (SettingsScope))]
    public static bool IsMouseDisabled { get; set; }

    /// <summary>The current <see cref="View"/> object that wants continuous mouse button pressed events.</summary>
    public static View? WantContinuousButtonPressedView { get; private set; }

    /// <summary>
    ///     Gets the view that grabbed the mouse (e.g. for dragging). When this is set, all mouse events will be routed to
    ///     this view until the view calls <see cref="UngrabMouse"/> or the mouse is released.
    /// </summary>
    public static View? MouseGrabView { get; private set; }

    /// <summary>Invoked when a view wants to grab the mouse; can be canceled.</summary>
    public static event EventHandler<GrabMouseEventArgs>? GrabbingMouse;

    /// <summary>Invoked when a view wants un-grab the mouse; can be canceled.</summary>
    public static event EventHandler<GrabMouseEventArgs>? UnGrabbingMouse;

    /// <summary>Invoked after a view has grabbed the mouse.</summary>
    public static event EventHandler<ViewEventArgs>? GrabbedMouse;

    /// <summary>Invoked after a view has un-grabbed the mouse.</summary>
    public static event EventHandler<ViewEventArgs>? UnGrabbedMouse;

    /// <summary>
    ///     Grabs the mouse, forcing all mouse events to be routed to the specified view until <see cref="UngrabMouse"/>
    ///     is called.
    /// </summary>
    /// <param name="view">View that will receive all mouse events until <see cref="UngrabMouse"/> is invoked.</param>
    public static void GrabMouse (View? view)
    {
        if (view is null || OnGrabbingMouse (view))
        {
            return;
        }

        OnGrabbedMouse (view);
        MouseGrabView = view;
    }

    /// <summary>Releases the mouse grab, so mouse events will be routed to the view on which the mouse is.</summary>
    public static void UngrabMouse ()
    {
        if (MouseGrabView is null)
        {
            return;
        }

#if DEBUG_IDISPOSABLE
        ObjectDisposedException.ThrowIf (MouseGrabView.WasDisposed, MouseGrabView);
#endif

        if (!OnUnGrabbingMouse (MouseGrabView))
        {
            View view = MouseGrabView;
            MouseGrabView = null;
            OnUnGrabbedMouse (view);
        }
    }

    /// <exception cref="Exception">A delegate callback throws an exception.</exception>
    private static bool OnGrabbingMouse (View? view)
    {
        if (view is null)
        {
            return false;
        }

        var evArgs = new GrabMouseEventArgs (view);
        GrabbingMouse?.Invoke (view, evArgs);

        return evArgs.Cancel;
    }

    /// <exception cref="Exception">A delegate callback throws an exception.</exception>
    private static bool OnUnGrabbingMouse (View? view)
    {
        if (view is null)
        {
            return false;
        }

        var evArgs = new GrabMouseEventArgs (view);
        UnGrabbingMouse?.Invoke (view, evArgs);

        return evArgs.Cancel;
    }

    /// <exception cref="Exception">A delegate callback throws an exception.</exception>
    private static void OnGrabbedMouse (View? view)
    {
        if (view is null)
        {
            return;
        }

        GrabbedMouse?.Invoke (view, new (view));
    }

    /// <exception cref="Exception">A delegate callback throws an exception.</exception>
    private static void OnUnGrabbedMouse (View? view)
    {
        if (view is null)
        {
            return;
        }

        UnGrabbedMouse?.Invoke (view, new (view));
    }

    // Used by OnMouseEvent to suppport MouseEnter and MouseLeave events
    internal static List<View?> ViewsUnderMouse { get; } = new ();

    /// <summary>Event fired when a mouse move or click occurs. Coordinates are screen relative.</summary>
    /// <remarks>
    ///     <para>
    ///         Use this event to receive mouse events in screen coordinates. Use <see cref="MouseEvent"/> to
    ///         receive mouse events relative to a <see cref="View.Viewport"/>.
    ///     </para>
    ///     <para>The <see cref="MouseEvent.View"/> will contain the <see cref="View"/> that contains the mouse coordinates.</para>
    /// </remarks>
    public static event EventHandler<MouseEvent>? MouseEvent;

    /// <summary>Called when a mouse event occurs. Raises the <see cref="MouseEvent"/> event.</summary>
    /// <remarks>This method can be used to simulate a mouse event, e.g. in unit tests.</remarks>
    /// <param name="mouseEvent">The mouse event with coordinates relative to the screen.</param>
    internal static void OnMouseEvent (MouseEvent mouseEvent)
    {
        if (IsMouseDisabled)
        {
            return;
        }

<<<<<<< Updated upstream
        var view = View.FindDeepestView (Current, mouseEvent.Position);
=======
        Stack<View?> viewsUnderMouse = View.GetViewsUnderMouse (mouseEvent.Position);

        View? deepestViewUnderMouse = viewsUnderMouse.TryPeek (out View? result) ? result : null;

        if ((mouseEvent.Flags == MouseFlags.Button1Pressed
             || mouseEvent.Flags == MouseFlags.Button2Pressed
             || mouseEvent.Flags == MouseFlags.Button3Pressed
             || mouseEvent.Flags == MouseFlags.Button4Pressed)
            && Popover is { Visible: true } && !ApplicationNavigation.IsInHierarchy (Popover, deepestViewUnderMouse, includeAdornments: true))
        {
            Popover.Visible = false;
        }
>>>>>>> Stashed changes

        if (deepestViewUnderMouse is { })
        {
#if DEBUG_IDISPOSABLE
            if (deepestViewUnderMouse.WasDisposed)
            {
                throw new ObjectDisposedException (deepestViewUnderMouse.GetType ().FullName);
            }
#endif
            mouseEvent.View = deepestViewUnderMouse;
        }

        MouseEvent?.Invoke (null, mouseEvent);

        if (mouseEvent.Handled)
        {
            return;
        }

        if (MouseGrabView is { })
        {

#if DEBUG_IDISPOSABLE
            if (MouseGrabView.WasDisposed)
            {
                throw new ObjectDisposedException (MouseGrabView.GetType ().FullName);
            }
#endif
            // If the mouse is grabbed, send the event to the view that grabbed it.
            // The coordinates are relative to the Bounds of the view that grabbed the mouse.
            Point frameLoc = MouseGrabView.ScreenToViewport (mouseEvent.Position);

            var viewRelativeMouseEvent = new MouseEvent
            {
                Position = frameLoc,
                Flags = mouseEvent.Flags,
                ScreenPosition = mouseEvent.Position,
                View = deepestViewUnderMouse ?? MouseGrabView
            };

            if ((MouseGrabView.Viewport with { Location = Point.Empty }).Contains (viewRelativeMouseEvent.Position) is false)
            {
                // The mouse has moved outside the bounds of the view that grabbed the mouse
                MouseGrabView.NewMouseLeaveEvent (mouseEvent);
            }

            //System.Diagnostics.Debug.WriteLine ($"{nme.Flags};{nme.X};{nme.Y};{mouseGrabView}");
            if (MouseGrabView?.NewMouseEvent (viewRelativeMouseEvent) is true)
            {
                return;
            }

            // ReSharper disable once ConditionIsAlwaysTrueOrFalse
            if (MouseGrabView is null && deepestViewUnderMouse is Adornment)
            {
                // The view that grabbed the mouse has been disposed
                return;
            }
        }

        // We can combine this into the switch expression to reduce cognitive complexity even more and likely
        // avoid one or two of these checks in the process, as well.
<<<<<<< Updated upstream
        WantContinuousButtonPressedView = view switch
                                          {
                                              { WantContinuousButtonPressed: true } => view,
                                              _                                     => null
                                          };

        if (view is not Adornment
         && (view is null || view == ApplicationOverlapped.OverlappedTop)
         && Current is { Modal: false }
         && ApplicationOverlapped.OverlappedTop != null
         && mouseEvent.Flags is not MouseFlags.ReportMousePosition and not 0)
        {
            // This occurs when there are multiple overlapped "tops"
            // E.g. "Mdi" - in the Background Worker Scenario
            View? top = ApplicationOverlapped.FindDeepestTop (Top!, mouseEvent.Position);
            view = View.FindDeepestView (top, mouseEvent.Position);

            if (view is { } && view != ApplicationOverlapped.OverlappedTop && top != Current && top is { })
            {
                ApplicationOverlapped.MoveCurrent ((Toplevel)top);
            }
        }
=======
        WantContinuousButtonPressedView = deepestViewUnderMouse switch
        {
            { WantContinuousButtonPressed: true } => deepestViewUnderMouse,
            _ => null
        };
>>>>>>> Stashed changes

        // May be null before the prior condition or the condition may set it as null.
        // So, the checking must be outside the prior condition.
        if (deepestViewUnderMouse is null)
        {
            return;
        }

        MouseEvent? me;

        if (deepestViewUnderMouse is Adornment adornment)
        {
            Point frameLoc = adornment.ScreenToFrame (mouseEvent.Position);

            me = new ()
            {
                Position = frameLoc,
                Flags = mouseEvent.Flags,
                ScreenPosition = mouseEvent.Position,
                View = deepestViewUnderMouse
            };
        }
        else if (deepestViewUnderMouse.ViewportToScreen (Rectangle.Empty with { Size = deepestViewUnderMouse.Viewport.Size }).Contains (mouseEvent.Position))
        {
            Point viewportLocation = deepestViewUnderMouse.ScreenToViewport (mouseEvent.Position);

            me = new ()
            {
                Position = viewportLocation,
                Flags = mouseEvent.Flags,
                ScreenPosition = mouseEvent.Position,
                View = deepestViewUnderMouse
            };
        }
        else
        {
            return;
        }

        // Mouse Enter/Leave events

        // Tell any views that are no longer under the mouse that the mouse has left and remove them from list
        List<View?> viewsToLeave = ViewsUnderMouse.Where (v => v is { } && !viewsUnderMouse.Contains (v)).ToList ();
        foreach (View? view in viewsToLeave)
        {
            if (view is null)
            {
                continue;
            }

            if (view is Adornment adornmentView)
            {
                Point frameLoc = adornmentView.ScreenToFrame (mouseEvent.Position);
                if (adornmentView.Parent is { } && !adornmentView.Contains (frameLoc))
                {
                    ViewsUnderMouse.Remove (view);
                    view.NewMouseLeaveEvent (me);
                }
            }
            else
            {
                Point viewportLocation = view.ScreenToViewport (mouseEvent.Position);
                if (!view.Contains (viewportLocation))
                {
                    ViewsUnderMouse.Remove (view);
                    view.NewMouseLeaveEvent (me);
                }

            }
        }

        // Tell any views that are now under the mouse (viewsUnderMouse) that the mouse has entered and add them to the list
        foreach (View? view in viewsUnderMouse)
        {
            if (view is null)
            {
                continue;
            }

            Point viewportLocation = view.ScreenToViewport (mouseEvent.Position);

            if (view is Adornment adornmentView)
            {

                if (adornmentView.Parent is { } && !adornmentView.Contains (viewportLocation))
                {
                    ViewsUnderMouse.Add (view);
                    view.NewMouseEnterEvent (me);
                }
            }
            else if (view.Contains (viewportLocation))
            {
                ViewsUnderMouse.Add (view);
                view.NewMouseEnterEvent (me);
            }
        }


        WantContinuousButtonPressedView = deepestViewUnderMouse.WantContinuousButtonPressed ? deepestViewUnderMouse : null;

        //Debug.WriteLine ($"OnMouseEvent: ({a.MouseEvent.X},{a.MouseEvent.Y}) - {a.MouseEvent.Flags}");
        if (deepestViewUnderMouse.Id == "mouseDemo")
        {

        }

        while (deepestViewUnderMouse.NewMouseEvent (me) is not true && MouseGrabView is not { })
        {
            if (deepestViewUnderMouse is Adornment adornmentView)
            {
                deepestViewUnderMouse = adornmentView.Parent!.SuperView;
            }
            else
            {
                deepestViewUnderMouse = deepestViewUnderMouse.SuperView;
            }

            if (deepestViewUnderMouse is null)
            {
                break;
            }

            Point boundsPoint = deepestViewUnderMouse.ScreenToViewport (mouseEvent.Position);

            me = new ()
            {
                Position = boundsPoint,
                Flags = mouseEvent.Flags,
                ScreenPosition = mouseEvent.Position,
                View = deepestViewUnderMouse
            };
        }

        ApplicationOverlapped.BringOverlappedTopToFront ();
    }

    #endregion Mouse handling
}