desplazamiento WPF ListBox al SelectedItem establecido en el código en un modelo de vista

Question

tengo una vista XAML con un cuadro de lista:

<control:ListBoxScroll ItemSource="{Binding Path=FooCollection}" 
         SelectedItem="{Binding SelectedFoo, Mode=TwoWay}" 
         ScrollSelectedItem="{Binding SelectedFoo}"> 
    <!-- data templates, etc. --> 
</control:ListBoxScroll> 

El elemento seleccionado está ligado a una propiedad, en mi opinión. Cuando el usuario selecciona un elemento en el cuadro de lista, mi propiedad SelectedFoo en el modelo de vista se actualiza. Cuando configuro la propiedad SelectedFoo en mi modelo de vista, se selecciona el elemento correcto en el cuadro de lista.

El problema es que si el SelectedFoo que está configurado en el código no está visible en este momento, debo llamar al ScrollIntoView en el cuadro de lista. Como mi ListBox está dentro de una vista y mi lógica está dentro de mi modelo de vista ... No pude encontrar una manera conveniente de hacerlo. Así que me ampliado ListBoxScroll:

class ListBoxScroll : ListBox 
{ 
    public static readonly DependencyProperty ScrollSelectedItemProperty = DependencyProperty.Register(
     "ScrollSelectedItem", 
     typeof(object), 
     typeof(ListBoxScroll), 
     new FrameworkPropertyMetadata(
      null, 
      FrameworkPropertyMetadataOptions.AffectsRender, 
      new PropertyChangedCallback(onScrollSelectedChanged))); 
    public object ScrollSelectedItem 
    { 
     get { return (object)GetValue(ScrollSelectedItemProperty); } 
     set { SetValue(ScrollSelectedItemProperty, value); } 
    } 

    private static void onScrollSelectedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
    { 
     var listbox = d as ListBoxScroll; 
     listbox.ScrollIntoView(e.NewValue); 
    } 
} 

Básicamente expone una nueva propiedad de dependencia ScrollSelectedItem la que se unen a la propiedad SelectedFoo en mi modelo de vista. Luego engancho en la devolución de llamada cambiada de la propiedad dependiente y despliego el elemento recién seleccionado en la vista.

¿Alguien más sabe de una forma más fácil de llamar a funciones en controles de usuario en una vista XAML respaldada por un modelo de vista? Es un poco de una carrera en torno a:

1. crear una propiedad dependiente
2. añadir una devolución de la propiedad cambió de devolución de llamada
3. función mango invocación dentro de la devolución de llamada estática

Sería bueno para poner la lógica en el método ScrollSelectedItem { set { pero el marco de dependencia parece escabullirse y se las arregla para funcionar sin llamarlo realmente.

Answer 1

Después de revisar las respuestas surgió un tema común: clases externas que escuchan el evento SelectionChanged del ListBox. Eso me hizo darse cuenta de que la estrategia de la propiedad dependiente fue exagerado y tan sólo pudiera tener la subclase escuche a sí mismo:

class ListBoxScroll : ListBox 
{ 
    public ListBoxScroll() : base() 
    { 
     SelectionChanged += new SelectionChangedEventHandler(ListBoxScroll_SelectionChanged); 
    } 

    void ListBoxScroll_SelectionChanged(object sender, SelectionChangedEventArgs e) 
    { 
     ScrollIntoView(SelectedItem); 
    } 
} 

Siento que esto es la solución más simple que hace lo que yo quiero.

Mención de honor va a adcool2007 para mostrar los comportamientos. Aquí hay un par de artículos para los interesados:

http://blogs.msdn.com/b/johngossman/archive/2008/05/07/the-attached-behavior-pattern.aspx
http://www.codeproject.com/KB/WPF/AttachedBehaviors.aspx

Creo que para los comportamientos genéricos que se añadirán a varios diferentes controles de usuario (por ejemplo, haga clic en los comportamientos, conductas, comportamientos de arrastre de animación, etc.) entonces los comportamientos adjuntos tienen mucho sentido. La razón por la que no quiero usarlos en este caso particular es que la implementación del comportamiento (llamando al ScrollIntoView) no es una acción genérica que puede ocurrir a cualquier control que no sea un ListBox.

Answer 2

Como esto es estrictamente un problema de Vista, no hay ninguna razón para que no pueda tener un controlador de eventos en el código detrás de su vista para este propósito. Escuche el ListBox.SelectionChanged y úselo para desplazar el elemento recién seleccionado a la vista.

private void ListBox_SelectionChanged(object sender, SelectionChangedEventArgs e) 
{ 
    ((ListBox)sender).ScrollIntoView(e.AddedItems[0]); 
} 

También no necesitan una deriva ListBox para hacer esto. Simplemente use un control estándar y cuando cambie el valor ListBox.SelectedItem (como se describe en su pregunta original), se ejecutará el controlador anterior y el elemento se desplazará a la vista.

<ListBox 
     ItemsSource="{Binding Path=FooCollection}" 
     SelectedItem="{Binding Path=SelectedFoo}" 
     SelectionChanged="ListBox_SelectionChanged" 
     /> 

Otro enfoque sería escribir una propiedad adjunta que escucha ICollectionView.CurrentChanged y luego invoca ListBox.ScrollIntoView para el nuevo elemento actual. Este es un enfoque más "reutilizable" si necesita esta funcionalidad para varios cuadros de lista. Puede encontrar un buen ejemplo aquí para comenzar: http://michlg.wordpress.com/2010/01/16/listbox-automatically-scroll-currentitem-into-view/

Answer 3

¿Ha intentado usar Comportamiento ... Aquí hay una Comportamiento ScrollInViewBehavior. Lo he usado para ListView y DataGrid ..... Creo que debería funcionar para ListBox ......

Hay que añadir una referencia a System.Windows.Interactivity utilizar Behavior<T> class

Comportamiento

public class ScrollIntoViewForListBox : Behavior<ListBox> 
{ 
    /// <summary> 
    /// When Beahvior is attached 
    /// </summary> 
    protected override void OnAttached() 
    { 
     base.OnAttached(); 
     this.AssociatedObject.SelectionChanged += AssociatedObject_SelectionChanged; 
    } 

    /// <summary> 
    /// On Selection Changed 
    /// </summary> 
    /// <param name="sender"></param> 
    /// <param name="e"></param> 
    void AssociatedObject_SelectionChanged(object sender, 
              SelectionChangedEventArgs e) 
    { 
     if (sender is ListBox) 
     { 
      ListBox listBox = (sender as ListBox); 
      if (listBox .SelectedItem != null) 
      { 
       listBox.Dispatcher.BeginInvoke(
        (Action) (() => 
            { 
             listBox.UpdateLayout(); 
             if (listBox.SelectedItem != 
              null) 
              listBox.ScrollIntoView(
               listBox.SelectedItem); 
            })); 
      } 
     } 
    } 
    /// <summary> 
    /// When behavior is detached 
    /// </summary> 
    protected override void OnDetaching() 
    { 
     base.OnDetaching(); 
     this.AssociatedObject.SelectionChanged -= 
      AssociatedObject_SelectionChanged; 

    } 
} 

Uso

Agregar alias para XAML como xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

entonces en su Control

 <ListBox ItemsSource="{Binding Path=MyList}" 
        SelectedItem="{Binding Path=MyItem, 
             Mode=TwoWay}" 
        SelectionMode="Single"> 
      <i:Interaction.Behaviors> 
       <Behaviors:ScrollIntoViewForListBox /> 
      </i:Interaction.Behaviors> 
     </ListBox> 

Ahora, cuando la propiedad "MyItem" esté configurada en ViewModel, la lista se desplazará cuando se reflejen los cambios.

Answer 4

Sé que esta es una pregunta antigua, pero mi búsqueda reciente del mismo problema me ha llevado a esto. Quería utilizar el enfoque de comportamiento, pero no quería una dependencia en el SDK de mezcla sólo para dar Behavior<T> Así que aquí está mi solución sin ella:

public static class ListBoxBehavior 
{ 
    public static bool GetScrollSelectedIntoView(ListBox listBox) 
    { 
     return (bool)listBox.GetValue(ScrollSelectedIntoViewProperty); 
    } 

    public static void SetScrollSelectedIntoView(ListBox listBox, bool value) 
    { 
     listBox.SetValue(ScrollSelectedIntoViewProperty, value); 
    } 

    public static readonly DependencyProperty ScrollSelectedIntoViewProperty = 
     DependencyProperty.RegisterAttached("ScrollSelectedIntoView", typeof (bool), typeof (ListBoxBehavior), 
              new UIPropertyMetadata(false, OnScrollSelectedIntoViewChanged)); 

    private static void OnScrollSelectedIntoViewChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
    { 
     var selector = d as Selector; 
     if (selector == null) return; 

     if (e.NewValue is bool == false) 
      return; 

     if ((bool) e.NewValue) 
     { 
      selector.AddHandler(Selector.SelectionChangedEvent, new RoutedEventHandler(ListBoxSelectionChangedHandler)); 
     } 
     else 
     { 
      selector.RemoveHandler(Selector.SelectionChangedEvent, new RoutedEventHandler(ListBoxSelectionChangedHandler)); 
     } 
    } 

    private static void ListBoxSelectionChangedHandler(object sender, RoutedEventArgs e) 
    { 
     if (!(sender is ListBox)) return; 

     var listBox = (sender as ListBox); 
     if (listBox.SelectedItem != null) 
     { 
      listBox.Dispatcher.BeginInvoke(
       (Action)(() => 
        { 
         listBox.UpdateLayout(); 
         if (listBox.SelectedItem !=null) 
          listBox.ScrollIntoView(listBox.SelectedItem); 
        })); 
     } 
    } 
} 

y luego uso es simplemente

<ListBox ItemsSource="{Binding Path=MyList}" 
     SelectedItem="{Binding Path=MyItem, Mode=TwoWay}" 
     SelectionMode="Single" 
     behaviors:ListBoxBehavior.ScrollSelectedIntoView="True"> 

Answer 5

Prueba esto:

private void lstBox_SelectionChanged(object sender, SelectionChangedEventArgs e) 
{ 
    lstBox.ScrollIntoView(lstBox.SelectedItem); 
} 

Answer 6

Después de atar varios métodos que encontré lo siguiente para ser la más simple y la mejor

lstbox.Items.MoveCurrentToLast(); 
lstbox.ScrollIntoView(lstbox.Items.CurrentItem); 

Answer 7

Respondí la respuesta de Ankesh e hice que no dependiera de la mezcla sdk. La desventaja de mi solución es que se aplicará a todas las listas de tu aplicación. Pero el lado positivo no es una clase personalizada necesaria.

Cuando su aplicación se está iniciando ...

internal static void RegisterFrameworkExtensionEvents() 
    { 
     EventManager.RegisterClassHandler(typeof(ListBox), ListBox.SelectionChangedEvent, new RoutedEventHandler(ScrollToSelectedItem)); 
    } 

    //avoid "async void" unless used in event handlers (or logical equivalent) 
    private static async void ScrollToSelectedItem(object sender, RoutedEventArgs e) 
    { 
     if (sender is ListBox) 
     { 
      var lb = sender as ListBox; 
      if (lb.SelectedItem != null) 
      { 
       await lb.Dispatcher.BeginInvoke((Action)delegate 
       { 
        lb.UpdateLayout(); 
        if (lb.SelectedItem != null) 
         lb.ScrollIntoView(lb.SelectedItem); 
       }); 
      } 
     } 
    } 

Esto hace que todos sus cuadros de lista para desplazarse seleccionado (que me gusta como un comportamiento por defecto).

Answer 8

estoy usando esto (en mi opinión) solución clara y fácil

listView.SelectionChanged += (s, e) => 
    listView.ScrollIntoView(listView.SelectedItem); 

donde se listView nombre de ListView de control en XAML, SelectedItem se ve afectado de mi MVVM y el código se inserta en el constructor en archivo xaml.cs