Почему список WPF меняет выбор при нажатии кнопки мыши вниз, а не вверх?

Question

Я никогда раньше этого не замечал, но WPB ListBox, похоже, меняет свой SelectedItem, когда мышь не работает, но еще не был выпущен. В качестве быстрого примера, просто создайте простой ListBox с несколькими ListBoxItems, например так:

<ListBox>
  <ListBoxItem>Hello</ListBoxItem>
  <ListBoxItem>World</ListBoxItem>
  <ListBoxItem>ListBox</ListBoxItem>
  <ListBoxItem>Test</ListBoxItem>
</ListBox>

запустите ваше приложение, нажмите кнопку мыши (не отпускайте ее!) И переместите мышь. SelectedItem будет меняться при движении мыши. Это иллюстрирует большую проблему (для меня, по крайней мере), что SelectedItem ListBox будет установлен как только при наведении курсора мыши, а не при наведении курсора вверх. Обычно это не проблема, но в моем случае я бы хотел включить перетаскивание элементов в моем ListBox без явного выбора элементов.

Я полагаю, что единственным выходом для меня является создание пользовательского ItemsControl или Selector с семантикой стиля выбора, подобной ListBox, так что на самом деле мой вопрос больше, почему ListBox работает таким образом? У кого-нибудь есть понимание этого?

Answer 1

Лично я предпочитаю MVVM и прикрепленные свойства для настройки поведения элементов.

Более того, решение, предложенное Томасом Косаром, похоже, не работает, когда свойство ItemsSource связано.

Вот что я сейчас использую (синтаксис C # 7)

public static class SelectorBehavior
{
    #region bool ShouldSelectItemOnMouseUp

    public static readonly DependencyProperty ShouldSelectItemOnMouseUpProperty = 
        DependencyProperty.RegisterAttached(
            "ShouldSelectItemOnMouseUp", typeof(bool), typeof(SelectorBehavior), 
            new PropertyMetadata(default(bool), HandleShouldSelectItemOnMouseUpChange));

    public static void SetShouldSelectItemOnMouseUp(DependencyObject element, bool value)
    {
        element.SetValue(ShouldSelectItemOnMouseUpProperty, value);
    }

    public static bool GetShouldSelectItemOnMouseUp(DependencyObject element)
    {
        return (bool)element.GetValue(ShouldSelectItemOnMouseUpProperty);
    }

    private static void HandleShouldSelectItemOnMouseUpChange(
        DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is Selector selector)
        {
            selector.PreviewMouseDown -= HandleSelectPreviewMouseDown;
            selector.MouseUp -= HandleSelectMouseUp;

            if (Equals(e.NewValue, true))
            {
                selector.PreviewMouseDown += HandleSelectPreviewMouseDown;
                selector.MouseUp += HandleSelectMouseUp;
            }
        }
    }

    private static void HandleSelectMouseUp(object sender, MouseButtonEventArgs e)
    {
        var selector = (Selector)sender;

        if (e.ChangedButton == MouseButton.Left && e.OriginalSource is Visual source)
        {
            var container = selector.ContainerFromElement(source);
            if (container != null)
            {
                var index = selector.ItemContainerGenerator.IndexFromContainer(container);
                if (index >= 0)
                {
                    selector.SelectedIndex = index;
                }
            }
        }
    }

    private static void HandleSelectPreviewMouseDown(object sender, MouseButtonEventArgs e)
    {
        e.Handled = e.ChangedButton == MouseButton.Left;
    }

    #endregion

}

Теперь вы можете применить это к любому ListBox (или классу, производному от Selector), например,

<ListBox ItemsSource="{Binding ViewModelItems}" 
    SelectedItem="{Binding SelectedViewModelItem}" 
    ui:SelectorBehavior.ShouldSelectItemOnMouseUp="True" />

Answer 2

Это может быть немного не по теме, но я только что столкнулся с подобной проблемой.Я не хочу делать перетаскивание, но я хочу выбирать элементы в ListBox на MouseUp, а не MouseDown.Хотя псевдокод Sheena может дать некоторую подсказку, мне все же потребовалось некоторое время, прежде чем я нашел правильное решение.Так что это мое решение для моей проблемы.

public class ListBoxSelectionItemChangedOnMouseUp : ListBox
{
    protected override void OnMouseUp(MouseButtonEventArgs e)
    {
        if (e.ChangedButton == MouseButton.Left)
        {
            DependencyObject obj = this.ContainerFromElement((Visual)e.OriginalSource);
            if (obj != null)
            {
                FrameworkElement element = obj as FrameworkElement;
                if (element != null)
                {
                    ListBoxItem item = element as ListBoxItem;
                    if (item != null && this.Items.Contains(item))
                    {
                        this.SelectedItem = item;
                    }
                }
            }
        }
    }

    protected override void OnPreviewMouseDown(MouseButtonEventArgs e)
    {
        e.Handled = true;
    }
}

Я также хотел выбрать только левой кнопкой мыши.В случае перетаскивания необходимо сохранить выбранный элемент в событии мыши вниз, а затем использовать его в событии мыши вверх.Надеюсь, это кому-нибудь поможет.

Answer 3

Альтернативный подход, который, кажется, работает для меня:

private class SelectOnMouseUpListViewItem: ListViewItem
{
    protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
    {
        if (IsSelected)
            e.Handled = true;
        base.OnMouseLeftButtonDown(e);
    }

    protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
    {
        if (!IsSelected)
            base.OnMouseLeftButtonDown(e);
        base.OnMouseLeftButtonUp(e);
    }
}

protected override DependencyObject GetContainerForItemOverride() // in ListView
{
    return new SelectOnMouseUpListViewItem();
}

Answer 4

Я предполагаю, что вы уже пытались создать новое событие нажатия мышью, которое делает то, что вы хотите, и переопределяете стандартное поведение таким образом ... вот некоторый псевдокод, который должен сработать:

ListBoxItem selected;
on_any_event_that_should_change_whats_selected()
{
    selected=whatever_you_want_selected;
}
on_selection_changed()
{
    theListBox.selectedItem=selected;
}

Мои wpf skillz немного ржавые, но я думаю, что вам нужно сохранить элемент, а затем сгенерировать контейнер, так что этот псевдокод является чрезмерным упрощением, но алгоритм должен сработать.

Answer 5

Томас ответил хорошо, но, возможно, его нужно настроить, чтобы он заработал.Я должен был сделать несколько бросков, и это не обязательно красиво, но он выполняет свою работу.

Это должно быть довольно просто, чтобы обновить ваши потребности.

private void MembersList_MouseUp(object sender, MouseButtonEventArgs e) {
    if (e.ChangedButton == MouseButton.Left) {
        DependencyObject obj = myListBox.ContainerFromElement((Visual)e.OriginalSource);
        if (obj != null) {
            FrameworkElement element = obj as FrameworkElement;
            if (element != null) {
                ListBoxItem item = element as ListBoxItem;
                if (item != null && ((MyViewModel)myListBox.DataContext).myListObject.Contains((MyListItem)item.DataContext)) {
                    myListBox.SelectedItem = item.DataContext;
                }
            }
        }
    }
}

Answer 6

Использование отражения никогда не бывает идеальным, но вот код, который работает для меня.

public class SelectOnMouseUpListBoxItem : ListBoxItem
{
    protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
    {
        var received = _receivedMouseDown;
        _receivedMouseDown = null;

        // validate that the mouse left button down event was called on this list box item
        if (received != this)
            return;

        var parent = WpfUtility.FindVisualParent<SelectOnMouseUpListBox>(this);

        parent.NotifyListItemClickedImp(this, e.ChangedButton);

        base.OnMouseLeftButtonUp(e);
    }

    private SelectOnMouseUpListBoxItem _receivedMouseDown;

    protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
    {
        _receivedMouseDown = this;

        e.Handled = true;

        base.OnMouseLeftButtonDown(e);
    }
}

public class SelectOnMouseUpListBox : ListBox
{
    static SelectOnMouseUpListBox()
    {
        _notifyListItemClickedMethodInfo = typeof(ListBox).GetMethod("NotifyListItemClicked", BindingFlags.Instance | BindingFlags.NonPublic);

        if (_notifyListItemClickedMethodInfo == null)
            throw new NotSupportedException("Failed to get NotifyListItemClicked method info by reflection");
    }

    private static readonly MethodInfo _notifyListItemClickedMethodInfo;

    protected override DependencyObject GetContainerForItemOverride()
    {
        return new SelectOnMouseUpListBoxItem();
    }

    public void NotifyListItemClickedImp(ListBoxItem item, MouseButton button)
    {
        _notifyListItemClickedMethodInfo.Invoke(this, new object[] {item, button});
    }
}

Это сохраняет обычное поведение выбора в зависимости от SelectionMode (Single, Multiple, Extended) ListBox.

Answer 7

Я обнаружил похожую проблему с ListView.Я не смог начать перетаскивание одного элемента без потери выбора другого.

Я решил это, унаследовав от ListView и обработав событие PreviewMouseDown.Вместо этого я выбрал элемент в MouseUp.

Остальная логика перетаскивания реализована с использованием Reactive Extensions .

ListBox аналогично ListView, поэтому выможет быть в состоянии просто получить из ListBox, и это будет работать.

Код:

public class DragDroppableListView : ListView
{
    private IDisposable _subscription;

    public DragDroppableListView()
    {
        Loaded += OnControlLoaded;
        Unloaded += OnControlUnloaded;
    }

    protected override void OnMouseUp(MouseButtonEventArgs e)
    {
        if (e.ChangedButton != MouseButton.Left) return;

        var obj = ContainerFromElement((Visual)e.OriginalSource);
        if (obj == null) return;

        var element = obj as FrameworkElement;
        if (element == null) return;

        var item = element as ListBoxItem;
        if (item == null) return;

        // select item
        item.IsSelected = true;
    }

    private void OnControlUnloaded(object sender, RoutedEventArgs e)
    {
        if (_subscription != null)
            _subscription.Dispose();
    }

    private void OnControlLoaded(object sender, RoutedEventArgs e)
    {
        var mouseDown = Observable.FromEventPattern<MouseButtonEventArgs>(this, "PreviewMouseDown");

        var mouseUp = Observable.FromEventPattern<MouseEventArgs>(this, "MouseUp");
        var mouseMove = Observable.FromEventPattern<MouseEventArgs>(this, "MouseMove");

        _subscription = mouseDown
            .Where(a => a.EventArgs.LeftButton == MouseButtonState.Pressed)
            .Where(o => !IsScrollBar(o.EventArgs))
            .Do(o => o.EventArgs.Handled = true)        // not allow listview select on mouse down
            .Select(ep => ep.EventArgs.GetPosition(this))
            .SelectMany(md => mouseMove
                .TakeWhile(ep => ep.EventArgs.LeftButton == MouseButtonState.Pressed)
                .Where(ep => IsMinimumDragSeed(md, ep.EventArgs.GetPosition(this)))
                .TakeUntil(mouseUp))
            .ObserveOnDispatcher()
            .Subscribe(_ => OnDrag());
    }

    private void OnDrag()
    {
        var item = GetItemUnderMouse();
        if (item == null) return;

        DragDrop.DoDragDrop(
            this,
            new DataObject(typeof(object), item),
            DragDropEffects.Copy | DragDropEffects.Move);
    }

    private ListViewItem GetItemUnderMouse()
    {
        return Items.Cast<object>()
            .Select(item => ItemContainerGenerator.ContainerFromItem(item))
            .OfType<ListViewItem>()
            .FirstOrDefault(lvi => lvi.IsMouseOver);
    }

    private static bool IsMinimumDragSeed(Point start, Point end)
    {
        return Math.Abs(end.X - start.X) >= SystemParameters.MinimumHorizontalDragDistance ||
               Math.Abs(end.Y - start.Y) >= SystemParameters.MinimumVerticalDragDistance;
    }

    private bool IsScrollBar(MouseEventArgs args)
    {
        var res = VisualTreeHelper.HitTest(this, args.GetPosition(this));
        if (res == null) return false;

        var depObj = res.VisualHit;
        while (depObj != null)
        {
            if (depObj is ScrollBar) return true;

            // VisualTreeHelper works with objects of type Visual or Visual3D.
            // If the current object is not derived from Visual or Visual3D,
            // then use the LogicalTreeHelper to find the parent element.
            if (depObj is Visual || depObj is System.Windows.Media.Media3D.Visual3D)
                depObj = VisualTreeHelper.GetParent(depObj);
            else
                depObj = LogicalTreeHelper.GetParent(depObj);
        }

        return false;
    }
}