Umożliwia przeciąganie okna WPF, bez względu na kliknięty element

Moje pytanie jest 2-krotne i mam nadzieję, że istnieją łatwiejsze rozwiązania dla obu zapewniane przez WPF, a nie standardowe rozwiązania z WinForms (które dostarczył Christophe Geers, zanim zrobiłem to wyjaśnienie).

Po pierwsze, czy istnieje sposób na umożliwienie przeciągania okna bez przechwytywania i przetwarzania zdarzeń kliknięcia i przeciągnięcia? Chodzi mi o to, że okno można przeciągać za pomocą paska tytułu, ale jeśli ustawię okno tak, aby go nie miało i nadal chcę móc go przeciągać, czy istnieje sposób, aby jakoś przekierować zdarzenia do tego, co obsługuje przeciąganie paska tytułu ?

Po drugie, czy istnieje sposób na zastosowanie procedury obsługi zdarzeń do wszystkich elementów w oknie? Tak jak w, ustaw okno do przeciągania bez względu na to, który element kliknie i przeciągnie użytkownik. Oczywiście bez ręcznego dodawania handlera do każdego elementu. Po prostu zrób to raz gdzieś?

Jasne, zastosuj następujące MouseDownzdarzenie swojegoWindow

private void Window_MouseDown(object sender, MouseButtonEventArgs e)
{
    if (e.ChangedButton == MouseButton.Left)
        this.DragMove();
}

Umożliwi to użytkownikom przeciąganie okna po kliknięciu / przeciągnięciu dowolnej kontrolki, Z WYJĄTKIEM kontrolek, które zjadają zdarzenie MouseDown ( e.Handled = true)

Możesz użyć PreviewMouseDownzamiast MouseDown, ale zdarzenie przeciągania zjada Clickzdarzenie, więc twoje okno przestaje reagować na zdarzenia kliknięcia lewym przyciskiem myszy. Jeśli NAPRAWDĘ chciałbyś mieć możliwość kliknięcia i przeciągnięcia formularza z dowolnej kontrolki, prawdopodobnie możesz użyć PreviewMouseDown, uruchomić licznik czasu, aby rozpocząć operację przeciągania i anulować operację, jeśli MouseUpzdarzenie zostanie uruchomione w ciągu X milisekund.

jeśli formularz wpf musi być przeciągany bez względu na to, gdzie został kliknięty, prostym obejściem jest użycie delegata do wywołania metody DragMove () na zdarzeniu onload systemu Windows lub zdarzeniu ładowania siatki

private void Grid_Loaded(object sender, RoutedEventArgs 
{
      this.MouseDown += delegate{DragMove();};
}

Czasami nie mamy dostępu Window, np. Jeśli korzystamy DevExpress, wszystko co jest dostępne to plikUIElement .

Krok 1: Dodaj dołączoną właściwość

Rozwiązaniem jest:

1. Podłącz do MouseMove wydarzeń;
2. Przeszukuj drzewo wizualne, aż znajdziemy pierwszego rodzica Window ;
3. Zadzwoń .DragMove()do naszego nowo odkrytego Window.

Kod:

using System.Windows;
using System.Windows.Input;
using System.Windows.Media;

namespace DXApplication1.AttachedProperty
{
    public class EnableDragHelper
    {
        public static readonly DependencyProperty EnableDragProperty = DependencyProperty.RegisterAttached(
            "EnableDrag",
            typeof (bool),
            typeof (EnableDragHelper),
            new PropertyMetadata(default(bool), OnLoaded));

        private static void OnLoaded(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs dependencyPropertyChangedEventArgs)
        {
            var uiElement = dependencyObject as UIElement;
            if (uiElement == null || (dependencyPropertyChangedEventArgs.NewValue is bool) == false)
            {
                return;
            }
            if ((bool)dependencyPropertyChangedEventArgs.NewValue  == true)
            {
                uiElement.MouseMove += UIElementOnMouseMove;
            }
            else
            {
                uiElement.MouseMove -= UIElementOnMouseMove;
            }

        }

        private static void UIElementOnMouseMove(object sender, MouseEventArgs mouseEventArgs)
        {
            var uiElement = sender as UIElement;
            if (uiElement != null)
            {
                if (mouseEventArgs.LeftButton == MouseButtonState.Pressed)
                {
                    DependencyObject parent = uiElement;
                    int avoidInfiniteLoop = 0;
                    // Search up the visual tree to find the first parent window.
                    while ((parent is Window) == false)
                    {
                        parent = VisualTreeHelper.GetParent(parent);
                        avoidInfiniteLoop++;
                        if (avoidInfiniteLoop == 1000)
                        {
                            // Something is wrong - we could not find the parent window.
                            return;
                        }
                    }
                    var window = parent as Window;
                    window.DragMove();
                }
            }
        }

        public static void SetEnableDrag(DependencyObject element, bool value)
        {
            element.SetValue(EnableDragProperty, value);
        }

        public static bool GetEnableDrag(DependencyObject element)
        {
            return (bool)element.GetValue(EnableDragProperty);
        }
    }
}

Krok 2: Dodaj dołączoną właściwość do dowolnego elementu, aby przeciągnąć okno

Użytkownik może przeciągnąć całe okno klikając na konkretny element, jeśli dodamy taką załączoną właściwość:

<Border local:EnableDragHelper.EnableDrag="True">
    <TextBlock Text="Click me to drag this entire window"/>
</Border>

Dodatek A: Opcjonalny przykład zaawansowany

W tym przykładzie z DevExpress zastępujemy pasek tytułu okna dokowanego naszym własnym szarym prostokątem, a następnie upewniamy się, że jeśli użytkownik kliknie i przeciągnie szarego prostokąta, okno będzie się przeciągać normalnie:

<dx:DXWindow x:Class="DXApplication1.MainWindow" Title="MainWindow" Height="464" Width="765" 
    xmlns:dx="http://schemas.devexpress.com/winfx/2008/xaml/core" 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:dxdo="http://schemas.devexpress.com/winfx/2008/xaml/docking" 
    xmlns:local="clr-namespace:DXApplication1.AttachedProperty"
    xmlns:dxdove="http://schemas.devexpress.com/winfx/2008/xaml/docking/visualelements"
    xmlns:themeKeys="http://schemas.devexpress.com/winfx/2008/xaml/docking/themekeys">

    <dxdo:DockLayoutManager FloatingMode="Desktop">
        <dxdo:DockLayoutManager.FloatGroups>
            <dxdo:FloatGroup FloatLocation="0, 0" FloatSize="179,204" MaxHeight="300" MaxWidth="400" 
                             local:TopmostFloatingGroupHelper.IsTopmostFloatingGroup="True"                             
                             >
                <dxdo:LayoutPanel ShowBorder="True" ShowMaximizeButton="False" ShowCaption="False" ShowCaptionImage="True" 
                                  ShowControlBox="True" ShowExpandButton="True" ShowInDocumentSelector="True" Caption="TradePad General" 
                                  AllowDock="False" AllowHide="False" AllowDrag="True" AllowClose="False"
                                  >
                    <Grid Margin="0">
                        <Grid.RowDefinitions>
                            <RowDefinition Height="Auto"/>
                            <RowDefinition Height="*"/>
                        </Grid.RowDefinitions>
                        <Border Grid.Row="0" MinHeight="15" Background="#FF515151" Margin="0 0 0 0"
                                                                  local:EnableDragHelper.EnableDrag="True">
                            <TextBlock Margin="4" Text="General" FontWeight="Bold"/>
                        </Border>
                        <TextBlock Margin="5" Grid.Row="1" Text="Hello, world!" />
                    </Grid>
                </dxdo:LayoutPanel>
            </dxdo:FloatGroup>
        </dxdo:DockLayoutManager.FloatGroups>
    </dxdo:DockLayoutManager>
</dx:DXWindow>

Zastrzeżenie: Ja nie związany z DevExpress . Ta technika będzie działać z dowolnym elementem użytkownika, w tym standardowym WPF lub Telerik (inny dobry dostawca biblioteki WPF).

private void Window_MouseDown(object sender, MouseButtonEventArgs e)
{
if (e.ChangedButton == MouseButton.Left)
    this.DragMove();
}

W niektórych przypadkach rzuca wyjątek (np. Jeśli w oknie masz również klikalny obraz, który po kliknięciu otwiera okno komunikatu. Po wyjściu z okna komunikatu pojawi się błąd). Bezpieczniej jest użyć

private void Window_MouseDown(object sender, MouseButtonEventArgs e)
{
if (Mouse.LeftButton == MouseButtonState.Pressed)
            this.DragMove();
}

Więc masz pewność, że lewy przycisk jest wciśnięty w tym momencie.

Formularz można przeciągać i upuszczać, klikając w dowolnym miejscu formularza, a nie tylko na pasku tytułu. Jest to przydatne, jeśli masz formularz bez obramowania.

W tym artykule na CodeProject przedstawiono jedno możliwe rozwiązanie do zaimplementowania tego:

http://www.codeproject.com/KB/cs/DraggableForm.aspx

Zasadniczo tworzony jest element potomny typu Form, w którym obsługiwane są zdarzenia myszy w dół, w górę i ruch.

• Mysz w dół: zapamiętaj pozycję
• Ruch myszy: zapisz nową lokalizację
• Mysz w górę: umieść formularz w nowej lokalizacji

A oto podobne rozwiązanie wyjaśnione w samouczku wideo:

http://www.youtube.com/watch?v=tJlY9aX73Vs

Nie pozwoliłbym na przeciąganie formularza, gdy użytkownik kliknie kontrolkę we wspomnianym formularzu. Użytkownicy uzyskują różne wyniki po kliknięciu różnych elementów sterujących. Kiedy mój formularz nagle zaczyna się poruszać, ponieważ kliknąłem pole listy, przycisk, etykietę ... itd. to byłoby mylące.

Jak już wspomniano w @ fjch1997 , wygodnie jest zaimplementować zachowanie. Tu jest logika rdzenia jest taki sam jak w @ loi.efy za odpowiedź :

public class DragMoveBehavior : Behavior<Window>
{
    protected override void OnAttached()
    {
        AssociatedObject.MouseMove += AssociatedObject_MouseMove;
    }

    protected override void OnDetaching()
    {
        AssociatedObject.MouseMove -= AssociatedObject_MouseMove;
    }

    private void AssociatedObject_MouseMove(object sender, MouseEventArgs e)
    {
        if (e.LeftButton == MouseButtonState.Pressed && sender is Window window)
        {
            // In maximum window state case, window will return normal state and
            // continue moving follow cursor
            if (window.WindowState == WindowState.Maximized)
            {
                window.WindowState = WindowState.Normal;

                // 3 or any where you want to set window location after
                // return from maximum state
                Application.Current.MainWindow.Top = 3;
            }

            window.DragMove();
        }
    }
}

Stosowanie:

<Window ...
        xmlns:h="clr-namespace:A.Namespace.Of.DragMoveBehavior"
        xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity">
    <i:Interaction.Behaviors>
        <h:DragMoveBehavior />
    </i:Interaction.Behaviors>
    ...
</Window>

To wszystko jest potrzebne!

private void UiElement_MouseMove(object sender, MouseEventArgs e)
    {
        if (e.LeftButton == MouseButtonState.Pressed)
        {
            if (this.WindowState == WindowState.Maximized) // In maximum window state case, window will return normal state and continue moving follow cursor
            {
                this.WindowState = WindowState.Normal;
                Application.Current.MainWindow.Top = 3;// 3 or any where you want to set window location affter return from maximum state
            }
            this.DragMove();
        }
    }

Najbardziej przydatna metoda, zarówno dla WPF, jak i formularza Windows, przykład WPF:

    [DllImport("user32.dll")]
    public static extern IntPtr SendMessage(IntPtr hWnd, int wMsg, int wParam, int lParam);

    public static void StartDrag(Window window)
    {
        WindowInteropHelper helper = new WindowInteropHelper(window);
        SendMessage(helper.Handle, 161, 2, 0);
    }

<Window
...
WindowStyle="None" MouseLeftButtonDown="WindowMouseLeftButtonDown"/>
<x:Code>
    <![CDATA[            
        private void WindowMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            DragMove();
        }
    ]]>
</x:Code>

źródło