platform/platform-impl/src/com/intellij/ide/util/ElementsChooser.java

/*
 * Copyright 2000-2009 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.intellij.ide.util;

import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.table.TableCellRenderer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * @see ChooseElementsDialog
 */
public class ElementsChooser<T> extends MultiStateElementsChooser<T, Boolean> {
  private static final BooleanMarkStateDescriptor MARK_STATE_DESCRIPTOR = new BooleanMarkStateDescriptor();

  public interface ElementsMarkListener<T> {
    void elementMarkChanged(T element, boolean isMarked);
  }

  public ElementsChooser(final boolean elementsCanBeMarked) {
    super(elementsCanBeMarked, ElementsChooser.<T>getMarkStateDescriptor());
  }

  public ElementsChooser(List<T> elements, boolean marked) {
    super(elements, marked, ElementsChooser.<T>getMarkStateDescriptor());
  }

  public void addElementsMarkListener(ElementsMarkListener<T> listener) {
    addElementsMarkListener(new ElementsMarkStateListenerAdapter<T>(listener));
  }

  public void removeElementsMarkListener(ElementsMarkListener<T> listener) {
    removeElementsMarkListener(new ElementsMarkStateListenerAdapter<T>(listener));
  }

  public void addElement(T element, final boolean isMarked) {
    addElement(element, getMarkState(isMarked));
  }

  /**
   * Check if element is marked
   *
   * @param element an element to test
   * @return true if element is marked
   */
  public boolean isElementMarked(T element) {
    return getElementMarkState(element);
  }

  /**
   * Update element mark
   *
   * @param element an element to test
   * @param marked  a new value of mark.
   */
  public void setElementMarked(T element, boolean marked) {
    setElementMarkState(element, getMarkState(marked));
  }

  public void addElement(T element, final boolean isMarked, ElementProperties elementProperties) {
    addElement(element, getMarkState(isMarked), elementProperties);
  }

  public void setElements(List<T> elements, boolean marked) {
    setElements(elements, getMarkState(marked));
  }

  public void markElements(Collection<T> elements) {
    markElements(elements, Boolean.TRUE);
  }

  @NotNull
  public List<T> getMarkedElements() {
    Map<T, Boolean> elementMarkStates = getElementMarkStates();
    List<T> elements = new ArrayList<T>();
    for (Map.Entry<T, Boolean> entry : elementMarkStates.entrySet()) {
      if (entry.getValue()) {
        elements.add(entry.getKey());
      }
    }
    return elements;
  }

  public void invertSelection() {
    final int count = getElementCount();
    for (int i = 0; i < count; i++) {
      T type = getElementAt(i);
      setElementMarked(type, !isElementMarked(type));
    }
  }

  public void setAllElementsMarked(boolean marked) {
    setAllElementsMarked(getMarkState(marked));
  }

  private static Boolean getMarkState(boolean marked) {
    return marked;
  }

  @SuppressWarnings("unchecked")
  private static <T> MarkStateDescriptor<T, Boolean> getMarkStateDescriptor() {
    return MARK_STATE_DESCRIPTOR;
  }

  private static class BooleanMarkStateDescriptor<T> implements MarkStateDescriptor<T, Boolean> {
    @NotNull
    @Override
    public Boolean getDefaultState(@NotNull T element) {
      return Boolean.FALSE;
    }

    @NotNull
    @Override
    public Boolean getNextState(@NotNull T element, @NotNull Boolean state) {
      return !state;
    }

    @Nullable
    @Override
    public Boolean getNextState(@NotNull Map<T, Boolean> elementsWithStates) {
      boolean currentlyMarked = true;
      for (Boolean state : elementsWithStates.values()) {
        currentlyMarked = state;
        if (!currentlyMarked) {
          break;
        }
      }
      return !currentlyMarked;
    }

    @Override
    public boolean isMarked(@NotNull Boolean state) {
      return state;
    }

    @Nullable
    @Override
    public Boolean getMarkState(@Nullable Object value) {
      return value instanceof Boolean ? ((Boolean)value) : null;
    }

    @Nullable
    @Override
    public TableCellRenderer getMarkRenderer() {
      return null;
    }
  }

  private static class ElementsMarkStateListenerAdapter<T> implements ElementsMarkStateListener<T, Boolean> {
    private final ElementsMarkListener<T> myListener;

    public ElementsMarkStateListenerAdapter(ElementsMarkListener<T> listener) {
      myListener = listener;
    }

    @Override
    public void elementMarkChanged(T element, Boolean markState) {
      myListener.elementMarkChanged(element, markState);
    }

    @Override
    public boolean equals(Object o) {
      if (this == o) return true;
      if (o == null || getClass() != o.getClass()) return false;

      ElementsMarkStateListenerAdapter that = (ElementsMarkStateListenerAdapter)o;

      if (!myListener.equals(that.myListener)) return false;

      return true;
    }

    @Override
    public int hashCode() {
      return myListener.hashCode();
    }
  }
}