Question

the problem is pretty easy if you reduce it to one class. Given the following image, I want to create a simple two sided control, which puts items from one list into the other depending on a boolean value.

EDIT: You can of course click on items in both lists, and the item switches to the other list. Also, a callback is called, in case I need to update some DB stuff…

I created a nice picture to movivate you a little bit, because I am stuck…

The world is not so simple like the example: How would you solve this for various classes.

Imagine a class like “Car” with “IsFast”. Or a class like “Fruits” with “ILikeIt”. I do not want to reprogramm the WPF control each time, I need some way to bind… (oh, I think I just got an idea)… but still, is there any good practice how to allow generic classes (like T) as long as they implement certain properties.. Or a wrapper class?

I have no idea, how would you solve it. Simple binding with OnClick Functions seems not enough… Not sure… And, by the way, “write 3 controls” IS a suitable answer. If it is simpler, just tell me.

alt text http://img31.imageshack.us/img31/96/listexample.png

Answer 1

I think I understand what you are after, this should get you started.

I am assuming that your usercontrol has two listviews, one intended for the true items named “TrueList”, the other for the false items named “FalseList”.

Extend your usercontrol from ItemsCollection and bind the ItemsSource property of each listview to the ItemsSource of the parent usercontrol.

Add a TrueFilter and a FalseFilter property to your usercontrol:

   Predicate<object> trueFilter;
   public Predicate<object> TrueFilter
   {
        get
        {
             return trueFilter;
        }
        set 
        {
             if (trueFilter!= null && this.TrueList.Items != null)
                 this.TrueList.Items.Filter -= trueFilter;

             trueFilter = value;

             if (trueFilter!= null && this.TrueList.Items != null)
                 this.TrueList.Items.Filter += trueFilter;
        }
    }

   Predicate<object> falseFilter;
   public Predicate<object> FalseFilter
   {
        get
        {
             return falseFilter;
        }
        set 
        {
             if (falseFilter!= null && this.FalseList.Items != null)
                 this.FalseList.Items.Filter -= falseFilter;

             filter = value;

             if (falseFilter!= null && this.FalseList.Items != null)
                 this.FalseList.Items.Filter += falseFilter;
        }
    }

Then create an “IToggle” (or some other more meaningful name) interface:

public interface IToggle
{
   Predicate<object> TrueFilter { get; }
   Predicate<object> FalseFilter { get; }
}

Then, extend ObservableCollection for each of your custom classes, implementing the “IToggle” interface:

public class Cars : ObservableCollection<Car>, IToggle
{
    Predicate<object> trueFilter;
    public Predicate<object> TrueFilter
    {
        get
        {
            if (trueFilter == null)
               trueFilter = new Predicate<object>(this.TrueFilterPredicate);
            return trueFilter;
        }
    }

    private bool TrueFilterPredicate(object value)
    {
       Car car = (Car)value;
       return car.IsFast;
    }

    Predicate<object> falseFilter;
    public Predicate<object> FalseFilter
    {
        get
        {
            if (falseFilter == null)
               falseFilter = new Predicate<object>(this.FalseFilterPredicate);
            return falseFilter;
        }
    }

    private bool FalseFilterPredicate(object value)
    {
       Car car = (Car)value;
       return !car.IsFast;
    }

Next, override the ItemsSource property on your user control:

public new IEnumerable ItemsSource
{
   get { return base.ItemsSource; }
   set
   {
        if (value != null && !(value is IToggle))
           throw new Exception("You may only bind this control to collections that implement IToggle.");

        base.ItemsSource = value;

        this.TrueFilter = base.ItemsSource == null ? null : (base.ItemsSource as IToggle).TrueFilter;
        this.FalseFilter = base.ItemsSource == null ? null : (base.ItemsSource as IToggle).FalseFilter;
   }
}

Finally, call TrueList.Items.Refresh() and FalseList.Items.Refresh() on your event callbacks to refresh the item views whenever you switch an item from true to false, and vice versa.

This solution still requires writing some implementation code for each custom class (the true and false filters), but it should keep the extra code to a minimum.

Alternatively, it would be a much simpler solution if you gave each of your custom classes a common interface, something like:

public interface Valid
{
   bool IsValid { get; set; }
}

Then you could use a single set of filters (or style setters, or databinding with converters) to work against the “Valid” interface. Instead of “Car.IsFast” and “Fruit.ILikeIt” you would use “Car.IsValid” and “Fruit.IsValid”.