The State Pattern in Multiple Selection

abstract class State
{
  public final Context context;
 
  protected State(Context context) {
    this.context = context;
  }
 
  public abstract State click();
  public abstract State shiftClick();
  public abstract State ctrlClick();
}

public class NoneSelectedState extends State
{
  public NoneSelectedState(Context context) {
    super(context);
  }
 
  @Override
  public State click() {
    context.setSelected(context.newItem);
    return new OneOrMoreSelectedState(new Context(context.table, context.newItem));
  }
 
  @Override
  public State shiftClick() {
    return click();
  }
 
  @Override
  public State ctrlClick() {
    return click();
  }
}

public class OneOrMoreSelectedState extends NoneSelectedState // inherit click() handling
{
  public OneOrMoreSelectedState(Context context) {
    super(context);
  }
 
  @Override
  public State shiftClick() {
    final Object [] itemsBetween = context.itemsBetween(context.anchorItem, context.newItem);
    context.setSelected(itemsBetween);
    final Context newContext = new Context(context.table, context.anchorItem); // anchor stays the same
    return new OneOrMoreSelectedState(newContext);
  }
 
  @Override
  public State ctrlClick() {
    if (context.isSelected(context.newItem))
      context.removeSelected(context.newItem);
    else
      context.addSelected(context.newItem);
  
    final Context newContext = new Context(context.table, context.newItem); // anchor changes
    return context.size() > 0
        ? new OneOrMoreSelectedState(newContext)
        : new NoneSelectedState(newContext);
  }
}

/**
 * Facade class for multi-selection.
 * Any selection holder must provide unique item-ids
 */
public final class MultiSelectUtil
{
  /**
   * Select items according to given event information.
   * @param clickedItemId the id of the currently clicked item.
   * @param shiftKeyDown true when "Shift" key was down on click.
   * @param ctrlKeyDown true when "Control" key was down on click.
   * @param selectionHolder where the selected items exist and should be set.
   * @param anchorItemIdProvider the object providing the anchor item-id.
   */
  public static void transition(
        Object clickedItemId,
        boolean shiftKeyDown,
        boolean ctrlKeyDown,
        SelectionHolder selectionHolder,
        AnchorItemIdHolder anchorItemIdProvider)
  {
    final Context context = new Context(
        selectionHolder,
        anchorItemIdProvider.getAnchorItemId(),
        clickedItemId);
   
    final State transition = (context.size() > 0)
        ? new OneOrMoreSelectedState(context)
        : new NoneSelectedState(context);
  
    final State followerState;
    if (shiftKeyDown)
      followerState = transition.shiftClick();
    else if (ctrlKeyDown)
      followerState = transition.ctrlClick();
    else
      followerState = transition.click();

    anchorItemIdProvider.setAnchorItemId(followerState.context.anchorItem);
  }
 
  private MultiSelectUtil() {} // do not instantiate
}

/**
 * Responsibilities of the list-widget.
 */
public interface SelectionHolder
{
  /** @return all unique ids of items in this list, in top-down order of visual appearance. */
  Collection<?> getItemIds();
 
  /** @return the unique ids of selected items in this list (order does not matter). */
  Collection<?> getSelection();
 
  /** @param newSelection the unique ids to be set as selected items in this list. */
  void setSelection(Collection<?> newSelection);
}

/**
 * Implementers hold the state of the selection,
 * i.e. the latest clicked item when no Shift key was pressed.
 * This is needed to select a range of items when a Shift-click follows.
 */
public interface AnchorItemIdHolder
{
  /** @return the current anchor item id. */
  Object getAnchorItemId();
 
  /** @param anchorItemId the new anchor item id to set. */
  void setAnchorItemId(Object anchorItemId);
}

public class Context
{
  final SelectionHolder table;
  final Object anchorItem;
  final Object newItem;
  
  public Context(SelectionHolder table, Object anchorItem, Object newItem) {
    this.table = table;
    this.anchorItem = anchorItem;
    this.newItem = newItem;
  }

  Context(SelectionHolder table, Object anchorItem) {
    this(table, anchorItem, null);
  }

  /** @return true when given item is currently selected. */
  public boolean isSelected(Object item) {
    return getMultipleSelection().contains(item);
  }

  /** @return the number of selected items. */
  public int size() {
    return getMultipleSelection().size();
  }
  
  /** Clears current selection and set given one. */
  public void setSelected(Object ... items) {
    setMultipleSelection(buildSelection(items));
  }
  
  /** Adds given items to current selection. */
  public void addSelected(Object ... items) {
    final Collection<?> selection = getMultipleSelection();
    final Set<Object> newSelection = buildSelection(items);
    newSelection.addAll(selection);
    setMultipleSelection(newSelection);
  }
  
  /** Removes given items from current selection. */
  public void removeSelected(Object ... items) {
    final Collection<?> selection = getMultipleSelection();
    final Set<Object> newSelection = buildSelection(selection.toArray());
    for (Object item : items)
      newSelection.remove(item);
    setMultipleSelection(newSelection);
  }
  
  /** @return all items between item1 and item2. */
  public Object [] itemsBetween(Object item1, Object item2) {
    final Set<Object> itemsBetween = buildSelection();
    Object startItem = null;
    
    for (Object itemId : table.getItemIds())  {
      if (startItem == null && itemsBetween.size() <= 0)
        if (itemId.equals(item1) || itemId.equals(item2))
          startItem = itemId;
      
      if (startItem != null)
        itemsBetween.add(itemId);
      
      if (startItem != null && (itemId.equals(startItem) == false || item1.equals(item2)))
        if (itemId.equals(item1) || itemId.equals(item2))
          startItem = null;
    }
    
    return itemsBetween.toArray();
  }
  
  
  private Set<Object> buildSelection(Object ... items) {
    final Set<Object> selection = new HashSet<Object>();
    for (Object item : items)
      selection.add(item);
    return selection;
  }
  
  private Collection<?> getMultipleSelection() {
    final Collection<?> selection = table.getSelection();
    return (selection == null) ? buildSelection() : selection;  // avoid null return
  }
  
  private void setMultipleSelection(Collection<?> newSelection) {
    table.setSelection(newSelection);
  }
}

public class MultiSelectUtilTest extends TestCase
{
  private static class TestSelectionHolder implements
    AnchorItemIdHolder,
    SelectionHolder
  {
    private Collection<?> itemIds = Arrays.asList(new Integer [] {
        Integer.valueOf(1),
        Integer.valueOf(2),
        Integer.valueOf(3),
        Integer.valueOf(4),
        Integer.valueOf(5),
        Integer.valueOf(6),
        Integer.valueOf(7),
      });
    
    private Collection<Object> selection = new HashSet<Object>();
    
    private Object anchorItemId;
    
    @Override
    public Collection<?> getItemIds() {
      return itemIds;
    }
    @Override
    public Collection<?> getSelection() {
      return selection;
    }
    @Override
    public void setSelection(Collection<?> newSelection) {
      selection.clear();
      selection.addAll(newSelection);
    }
    @Override
    public Object getAnchorItemId() {
      return anchorItemId;
    }
    @Override
    public void setAnchorItemId(Object anchorItemId) {
      this.anchorItemId = anchorItemId;
    }
  }
  
  public void testAutomaton()  {
    final TestSelectionHolder table = new TestSelectionHolder();
    assertEquals(0, table.getSelection().size());
    
    // click on "3"
    MultiSelectUtil.transition(Integer.valueOf(3), false, false, table, table);
    assertEquals(1, table.getSelection().size());
    assertEquals(Integer.valueOf(3), table.getSelection().iterator().next());
    
    // Shift-click on "5" to select "3", "4", and "5"
    MultiSelectUtil.transition(Integer.valueOf(5), true, false, table, table);
    assertEquals(3, table.getSelection().size());
    assertTrue(table.getSelection().contains(Integer.valueOf(3)));
    assertTrue(table.getSelection().contains(Integer.valueOf(4)));
    assertTrue(table.getSelection().contains(Integer.valueOf(5)));
    
    // Ctrl-click on "4" to remove it from selection
    MultiSelectUtil.transition(Integer.valueOf(4), false, true, table, table);
    assertEquals(2, table.getSelection().size());
    assertTrue(table.getSelection().contains(Integer.valueOf(3)));
    assertTrue(table.getSelection().contains(Integer.valueOf(5)));
    
    // Shift-click on "2" to select "2", "3", and "4",
    // because anchor has been set to "4" by preceding Ctrl-click
    MultiSelectUtil.transition(Integer.valueOf(2), true, false, table, table);
    assertEquals(3, table.getSelection().size());
    assertTrue(table.getSelection().contains(Integer.valueOf(2)));
    assertTrue(table.getSelection().contains(Integer.valueOf(3)));
    assertTrue(table.getSelection().contains(Integer.valueOf(4)));
    
    // simple click on "1" should select only "1"
    MultiSelectUtil.transition(Integer.valueOf(1), false, false, table, table);
    assertEquals(1, table.getSelection().size());
    assertTrue(table.getSelection().contains(Integer.valueOf(1)));
    
    // Ctrl-click on "7" should select "1" and "7"
    MultiSelectUtil.transition(Integer.valueOf(7), false, true, table, table);
    assertEquals(2, table.getSelection().size());
    assertTrue(table.getSelection().contains(Integer.valueOf(1)));
    assertTrue(table.getSelection().contains(Integer.valueOf(7)));
  }
}