source: src/main/java/genius/gui/panels/SelectionModelAdapter.java@ 345

package genius.gui.panels;

import java.util.ArrayList;
import java.util.List;

import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;

import genius.core.listener.Listener;

/**
 * Adapts the {@link SubsetSelectionModel} to a {@link ListSelectionModel}.
 * 
 * The ListSelectionModel (jlist) supports quite complex selection modes:
 * ctrl-click , dragging, and combinations of these. We really only want to
 * support dragging so we ignore the ctrl- and removal stuff.
 */
public class SelectionModelAdapter<ItemType> implements ListSelectionModel {

        private SubsetSelectionModel<ItemType> model;

        /**
         * drag start point. Valid while user is dragging
         */
        private int anchorSelectionIndex = -1;
        /**
         * current drag end point. Valid while user is dragging
         */
        private int leadSelectionIndex = -1;
        /**
         * True while the user is dragging.
         */
        private boolean valueIsAdjusting;
        /**
         * Selected selection mode.
         */
        private int selectionMode;

        /**
         * The selection in the model at the time the drag starts
         */
        private List<ItemType> initialSelection;

        public SelectionModelAdapter(SubsetSelectionModel<ItemType> model) {
                this.model = model;

        }

        @Override
        public void setSelectionInterval(int index0, int index1) {
                if (anchorSelectionIndex == -1) {
                        // user just started dragging
                        anchorSelectionIndex = index0;
                        initialSelection = model.getSelectedItems();
                }
                leadSelectionIndex = index1;
                reverseSelection();
        }

        /**
         * Reverse the selection state of items in the range [anchor, lead]
         */
        private void reverseSelection() {
                ArrayList<ItemType> newSelection = new ArrayList<ItemType>(initialSelection);
                for (int n = Math.min(anchorSelectionIndex, leadSelectionIndex); //
                                n <= Math.max(anchorSelectionIndex, leadSelectionIndex); n++) {
                        ItemType item = model.getAllItems().get(n);
                        // reverse the selection of item.
                        if (newSelection.contains(item)) {
                                newSelection.remove(item);
                        } else {
                                newSelection.add(item);
                        }
                        model.select(newSelection);
                }

        }

        @Override
        public void addSelectionInterval(int index0, int index1) {
                System.out.println("ignore User added " + index0 + " " + index1);
        }

        @Override
        public void removeSelectionInterval(int index0, int index1) {
                System.out.println("ignore user removed " + index0 + " " + index1);
        }

        @Override
        public int getMinSelectionIndex() {
                if (model.getSelectedItems().isEmpty()) {
                        return -1;
                }
                return model.getAllItems().indexOf(model.getSelectedItems().get(0));
        }

        @Override
        public int getMaxSelectionIndex() {
                return model.getAllItems().size() - 1;
        }

        @Override
        public boolean isSelectedIndex(int index) {
                return model.getSelectedItems().contains(model.getAllItems().get(index));
        }

        @Override
        public int getAnchorSelectionIndex() {
                return anchorSelectionIndex;
        }

        @Override
        public void setAnchorSelectionIndex(int index) {
                System.out.println("anchor set to " + index);
                anchorSelectionIndex = index;
        }

        @Override
        public int getLeadSelectionIndex() {
                return leadSelectionIndex;
        }

        @Override
        public void setLeadSelectionIndex(int index) {
                leadSelectionIndex = index;
        }

        @Override
        public void clearSelection() {
                model.select(new ArrayList<ItemType>());
        }

        @Override
        public boolean isSelectionEmpty() {
                return model.getSelectedItems().isEmpty();
        }

        @Override
        public void insertIndexInterval(int index, int length, boolean before) {
                System.out.println("insert index blabla" + index + length);
        }

        @Override
        public void removeIndexInterval(int index0, int index1) {
                // ???????
        }

        @Override
        public void setValueIsAdjusting(boolean valueIsAdjusting) {
                this.valueIsAdjusting = valueIsAdjusting;
                if (this.valueIsAdjusting) {
                        // start drag
                        anchorSelectionIndex = -1;
                }
        }

        @Override
        public boolean getValueIsAdjusting() {
                return valueIsAdjusting;
        }

        @Override
        public void setSelectionMode(int selectionMode) {
                this.selectionMode = selectionMode;
        }

        @Override
        public int getSelectionMode() {
                return selectionMode;
        }

        @Override
        public void addListSelectionListener(final ListSelectionListener x) {
                model.addListener(new ListSelectionListenerAdapter<ItemType>(x));
        }

        @Override
        public void removeListSelectionListener(ListSelectionListener x) {
                model.removeListener(new ListSelectionListenerAdapter<ItemType>(x));
        }

}

/**
 * adapts a {@link ListSelectionListener} to a {@link Listener}
 *
 * @param <ItemType>
 */
class ListSelectionListenerAdapter<ItemType> implements Listener<ItemType> {

        private ListSelectionListener listener;

        public ListSelectionListenerAdapter(ListSelectionListener x) {
                this.listener = x;
        }

        @Override
        public void notifyChange(Object data) {
                // our model does not report this kind of detail. Hack it.
                listener.valueChanged(new ListSelectionEvent(this, 0, 0, false));
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + ((listener == null) ? 0 : listener.hashCode());
                return result;
        }

        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                ListSelectionListenerAdapter other = (ListSelectionListenerAdapter) obj;
                if (listener == null) {
                        if (other.listener != null)
                                return false;
                } else if (!listener.equals(other.listener))
                        return false;
                return true;
        }

}