How to test if a window is being dragged C# WPF

Question

I have a title-less window, as I wanted to create a window style of my own.

The title and minimize, maximize and close buttons are in a dock panel. I have added the following event handler to maximize, restore and drag the window.

The problem comes when the window is maximized.

What I have found is that whenever I do a single click on the title is restores. When I only want it to restore if it is double clicked or dragged. I can see why it is happening but unsure how to resolve this.

    public void TITLEBAR_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        DockPanel dp = (DockPanel)sender;
        Window parentWindow = Window.GetWindow(dp);
        bool doubleClick = IsDoubleClick(sender, e);

        if (e.ChangedButton == MouseButton.Left && e.LeftButton == MouseButtonState.Pressed && !doubleClick)
        {


            if (parentWindow.WindowState == WindowState.Maximized)
            {
                double mouseX = e.GetPosition(parentWindow).X;
                double width = parentWindow.RestoreBounds.Width;
                System.Drawing.Rectangle screenBounds = getCurrentScreenBounds(parentWindow);
                double x = screenBounds.Left + (mouseX - ((width / 100.00) * ((100.00 / screenBounds.Width) * mouseX)));

                if (x < 0)
                {
                    x = 0;
                }
                else
                {
                    if (x + width > screenBounds.Left + screenBounds.Width)
                    {
                        x = screenBounds.Left + screenBounds.Width - width;
                    }
                }

                parentWindow.Left = x;
                parentWindow.Top = screenBounds.Top;
                parentWindow.WindowState = System.Windows.WindowState.Normal;
            }

            parentWindow.DragMove();
            //MessageBox.Show("");
        }

        if (doubleClick)
        {
            if (parentWindow.WindowState == System.Windows.WindowState.Maximized)
            {
                parentWindow.WindowState = System.Windows.WindowState.Normal;
            }
            else
            {
                parentWindow.WindowState = System.Windows.WindowState.Maximized;
            }
        }
    }

Along with this class:

public static class MouseButtonHelper
{
    private const long k_DoubleClickSpeed = 500;
    private const double k_MaxMoveDistance = 10;

    private static long _LastClickTicks = 0;
    private static System.Windows.Point _LastPosition;
    private static WeakReference _LastSender;

    public static bool IsDoubleClick(object sender, System.Windows.Input.MouseButtonEventArgs e)
    {
        System.Windows.Point position = e.GetPosition(null);
        long clickTicks = DateTime.Now.Ticks;
        long elapsedTicks = clickTicks - _LastClickTicks;
        long elapsedTime = elapsedTicks / TimeSpan.TicksPerMillisecond;
        bool quickClick = (elapsedTime <= k_DoubleClickSpeed);
        bool senderMatch = (_LastSender != null && sender.Equals(_LastSender.Target));

        if (senderMatch && quickClick && position.Distance(_LastPosition) <= k_MaxMoveDistance)
        {
            // Double click!
            _LastClickTicks = 0;
            _LastSender = null;
            return true;
        }

        // Not a double click
        _LastClickTicks = clickTicks;
        _LastPosition = position;
        if (!quickClick)
            _LastSender = new WeakReference(sender);
        return false;
    }


    private static double Distance(this System.Windows.Point pointA, System.Windows.Point pointB)
    {
        double x = pointA.X - pointB.X;
        double y = pointA.Y - pointB.Y;
        return Math.Sqrt(x * x + y * y);
    }
}

And this to work out bounds of the current screen.

public static class WindowHelper
{
    public static System.Drawing.Rectangle getCurrentScreenBounds(System.Windows.Window pWnd)
    {
        System.Windows.Forms.Screen parentScreen = GetCurrentScreen(pWnd);

        if (parentScreen == null)
        {
            return System.Windows.Forms.Screen.PrimaryScreen.Bounds;
        }

        return parentScreen.Bounds;
    }

    private static System.Windows.Forms.Screen GetCurrentScreen(System.Windows.Window pWnd)
    {
        System.Drawing.Rectangle intersectingRect = new System.Drawing.Rectangle();
        System.Drawing.Rectangle windowRect = new System.Drawing.Rectangle(Convert.ToInt32(pWnd.Left), Convert.ToInt32(pWnd.Top), Convert.ToInt32(pWnd.Width), Convert.ToInt32(pWnd.Height));
        int largestIntersectingArea = 0;
        System.Windows.Forms.Screen curScreen = null;

        foreach (System.Windows.Forms.Screen s in System.Windows.Forms.Screen.AllScreens)
        {
            if (s.Bounds.IntersectsWith(windowRect))
            {
                intersectingRect = System.Drawing.Rectangle.Intersect(s.Bounds, windowRect);
                int intersectingArea = intersectingRect.Width * intersectingRect.Height;
                if (intersectingArea > largestIntersectingArea)
                {
                    largestIntersectingArea = intersectingArea;
                    curScreen = s;
                }
            }
        }

        return curScreen;
    }
}

Answer 1

There is a WPF element (control) named Thumb, I use that for making drag-able parts. It has a DragDelta event which you can use to examine HorizontalOffset and VerticalOffset of the drag-able part. You can save previous values and check if new values are the same or changed; which means it is being dragged.

(Just a suggestion which worked for me).

Answer 2

Ok so maybe someone will find this helpful.

I changed things around so that it recognizes the drag through two events, in the MouseMove and MouseLeftButtonDown events.

MouseLeftButtonDown captures a possible start position for drag in setStartPosition().

    public void TITLEBAR_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        DockPanel dp = (DockPanel)sender;
        Window parentWindow = Window.GetWindow(dp);
        doubleClick = IsDoubleClick(sender, e);

        if (e.ChangedButton == MouseButton.Left && e.LeftButton == MouseButtonState.Pressed && !doubleClick)
        {
            if (parentWindow.WindowState == WindowState.Maximized)
            {
                setStartPosition(sender, e);
            }
        }

        if (doubleClick)
        {
            if (parentWindow.WindowState == System.Windows.WindowState.Maximized)
            {
                parentWindow.WindowState = System.Windows.WindowState.Normal;
            }
            else
            {
                parentWindow.WindowState = System.Windows.WindowState.Maximized;
            }
        }
    }

    private void TITLEBAR_MouseMove(object sender, MouseEventArgs e)
    {
        DockPanel dp = (DockPanel)sender;
        Window parentWindow = Window.GetWindow(dp);

        if (e.LeftButton == MouseButtonState.Pressed)
        {
            if (IsDragging(sender, e) && !doubleClick)
            {
                if (parentWindow.WindowState == WindowState.Maximized)
                {
                    double mouseX = e.GetPosition(parentWindow).X;
                    double width = parentWindow.RestoreBounds.Width;
                    System.Drawing.Rectangle screenBounds = getCurrentScreenBounds(parentWindow);
                    double x = screenBounds.Left + (mouseX - ((width / 100.00) * ((100.00 / screenBounds.Width) * mouseX)));

                    if (x < 0)
                    {
                        x = 0;
                    }
                    else
                    {
                        if (x + width > screenBounds.Left + screenBounds.Width)
                        {
                            x = screenBounds.Left + screenBounds.Width - width;
                        }
                    }

                    parentWindow.Left = x;
                    parentWindow.Top = screenBounds.Top;
                    parentWindow.WindowState = System.Windows.WindowState.Normal;
                }

                parentWindow.DragMove();
            }
        }

    }

Here is the modified class:

public static class MouseButtonHelper
{
    private const long k_DoubleClickSpeed = 500;
    private const double k_MaxMoveDistance = 10;

    private static long _LastClickTicks = 0;
    private static System.Windows.Point _LastPosition;
    private static WeakReference _LastSender;

    private static System.Windows.Point _DragStartPosition;

    public static bool IsDoubleClick(object sender, System.Windows.Input.MouseButtonEventArgs e)
    {
        System.Windows.Point position = e.GetPosition(null);
        long clickTicks = DateTime.Now.Ticks;
        long elapsedTicks = clickTicks - _LastClickTicks;
        long elapsedTime = elapsedTicks / TimeSpan.TicksPerMillisecond;
        bool quickClick = (elapsedTime <= k_DoubleClickSpeed);
        bool senderMatch = (_LastSender != null && sender.Equals(_LastSender.Target));

        if (senderMatch && quickClick && position.Distance(_LastPosition) <= k_MaxMoveDistance)
        {
            // Double click!
            _LastClickTicks = 0;
            _LastSender = null;
            return true;
        }

        // Not a double click
        _LastClickTicks = clickTicks;
        _LastPosition = position;
        if (!quickClick)
            _LastSender = new WeakReference(sender);
        return false;
    }

    public static void setStartPosition(object sender, System.Windows.Input.MouseButtonEventArgs e)
    {
        _DragStartPosition = e.GetPosition(null);
    }

    public static bool IsDragging(object sender, System.Windows.Input.MouseEventArgs e)
    {
        System.Windows.Point mousePos = e.GetPosition(null);
        System.Windows.Vector diff = _DragStartPosition - mousePos;

        if (Math.Abs(diff.X) > System.Windows.SystemParameters.MinimumHorizontalDragDistance || Math.Abs(diff.Y) > System.Windows.SystemParameters.MinimumVerticalDragDistance)
        {
            return true;
        }
        return false;
    }

    private static double Distance(this System.Windows.Point pointA, System.Windows.Point pointB)
    {
        double x = pointA.X - pointB.X;
        double y = pointA.Y - pointB.Y;
        return Math.Sqrt(x * x + y * y);
    }
}