Java tutorial
/* ****************************************************************************** * Copyright (c) 2006-2012 XMind Ltd. and others. * * This file is a part of XMind 3. XMind releases 3 and * above are dual-licensed under the Eclipse Public License (EPL), * which is available at http://www.eclipse.org/legal/epl-v10.html * and the GNU Lesser General Public License (LGPL), * which is available at http://www.gnu.org/licenses/lgpl.html * See http://www.xmind.net/license.html for details. * * Contributors: * XMind Ltd. - initial API and implementation *******************************************************************************/ package org.xmind.ui.viewers; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.eclipse.core.runtime.Assert; import org.eclipse.core.runtime.SafeRunner; import org.eclipse.draw2d.ColorConstants; import org.eclipse.jface.layout.GridDataFactory; import org.eclipse.jface.layout.GridLayoutFactory; import org.eclipse.jface.util.OpenStrategy; import org.eclipse.jface.util.SafeRunnable; import org.eclipse.jface.viewers.CheckStateChangedEvent; import org.eclipse.jface.viewers.IBaseLabelProvider; import org.eclipse.jface.viewers.ICheckStateListener; import org.eclipse.jface.viewers.ICheckable; import org.eclipse.jface.viewers.IColorProvider; import org.eclipse.jface.viewers.IElementComparer; import org.eclipse.jface.viewers.IFontProvider; import org.eclipse.jface.viewers.ILabelProvider; import org.eclipse.jface.viewers.StructuredViewer; import org.eclipse.jface.viewers.ViewerComparator; import org.eclipse.swt.SWT; import org.eclipse.swt.events.DisposeEvent; import org.eclipse.swt.events.DisposeListener; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.graphics.Color; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.widgets.Button; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Label; import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.Widget; public class CheckListViewer extends StructuredViewer implements ICheckable { protected static class CheckItem { private CheckListViewer listViewer; private Object data; private Composite bar; private Button checkbox; private Label imageLabel; private Label textLabel; private boolean selected; private boolean internalSetChecked = false; public CheckItem(CheckListViewer listViewer, Composite parent) { this.listViewer = listViewer; bar = new Composite(parent, SWT.NO_FOCUS); bar.setBackground(parent.getBackground()); bar.setData(this); GridLayoutFactory.fillDefaults().numColumns(3).extendedMargins(5, 5, 1, 1).applyTo(bar); checkbox = new Button(bar, SWT.CHECK); checkbox.setText(""); //$NON-NLS-1$ checkbox.setBackground(bar.getBackground()); GridDataFactory.swtDefaults().align(SWT.FILL, SWT.CENTER).applyTo(checkbox); imageLabel = new Label(bar, SWT.NONE); imageLabel.setImage(null); imageLabel.setBackground(bar.getBackground()); GridDataFactory.swtDefaults().align(SWT.FILL, SWT.CENTER).applyTo(imageLabel); textLabel = new Label(bar, SWT.NONE); textLabel.setText(""); //$NON-NLS-1$ textLabel.setBackground(bar.getBackground()); GridDataFactory.fillDefaults().grab(true, false).align(SWT.FILL, SWT.CENTER).applyTo(textLabel); addControlListeners(); } public Object getData() { return data; } public void setData(Object data) { this.data = data; } public CheckListViewer getListViewer() { return listViewer; } public Control getControl() { return bar; } protected Composite getBarComposite() { return bar; } protected void addControlListeners() { Listener listener = new Listener() { public void handleEvent(Event event) { int type = event.type; switch (type) { case SWT.Paint: paintBackground(event.gc); break; case SWT.MouseDown: if (event.widget == checkbox) { selectSingle(); } else { userSelect(event); if ((OpenStrategy.getOpenMethod() & OpenStrategy.SINGLE_CLICK) != 0) { userOpen(event); } } break; case SWT.MouseDoubleClick: if (OpenStrategy.getOpenMethod() == OpenStrategy.DOUBLE_CLICK) { userOpen(event); } break; case SWT.MouseHover: if ((OpenStrategy.getOpenMethod() & OpenStrategy.SELECT_ON_HOVER) != 0) { userSelect(event); } break; case SWT.Selection: if (!internalSetChecked) { userCheck(); } break; } } }; bar.addListener(SWT.Paint, listener); bar.addListener(SWT.MouseDown, listener); bar.addListener(SWT.MouseDoubleClick, listener); bar.addListener(SWT.MouseHover, listener); imageLabel.addListener(SWT.MouseDown, listener); imageLabel.addListener(SWT.MouseDoubleClick, listener); imageLabel.addListener(SWT.MouseHover, listener); textLabel.addListener(SWT.MouseDown, listener); textLabel.addListener(SWT.MouseDoubleClick, listener); textLabel.addListener(SWT.MouseHover, listener); checkbox.addListener(SWT.MouseDown, listener); checkbox.addListener(SWT.Selection, listener); } protected void userCheck() { getListViewer().fireChecked(this); } protected void paintBackground(GC gc) { if (isSelected()) { Rectangle bounds = bar.getBounds(); bounds.x = 0; bounds.y = 0; //Rectangle labelBounds = label.getBounds(); gc.setBackground(getSelectionBackground()); gc.fillRectangle(bounds); //gc.fillRectangle( labelBounds.x, bounds.y, bounds.x + bounds.width - labelBounds.x, bounds.height ); } } protected void userSelect(Event e) { selectSingle(); getListViewer().getControl().setFocus(); getListViewer().handleSelect(new SelectionEvent(e)); } protected void userOpen(Event e) { selectSingle(); getListViewer().getControl().setFocus(); getListViewer().handleOpen(new SelectionEvent(e)); } protected void selectSingle() { getListViewer().setSelectedItem(this); } public Button getCheckbox() { return checkbox; } public Label getLabel() { return textLabel; } public boolean isChecked() { return checkbox.getSelection(); } public void setChecked(boolean checked) { internalSetChecked = true; checkbox.setSelection(checked); internalSetChecked = false; } public String getText() { return textLabel.getText(); } public void setText(String text) { textLabel.setText(text); } public Image getImage() { return imageLabel.getImage(); } public void setImage(Image image) { imageLabel.setImage(image); } public boolean isSelected() { return selected; } public void setSelection(boolean selected) { if (selected == this.selected) return; this.selected = selected; bar.redraw(); textLabel.redraw(); if (selected) { checkbox.setBackground(getSelectionBackground()); imageLabel.setBackground(getSelectionBackground()); textLabel.setBackground(getSelectionBackground()); textLabel.setForeground(getSelectionTextColor()); } else { Color background = bar.getBackground(); checkbox.setBackground(background); imageLabel.setBackground(background); textLabel.setBackground(background); textLabel.setForeground(null); } } public void dispose() { bar.dispose(); } public boolean isDisposed() { return bar.isDisposed(); } } private static Color selectionBackground = null; private static Color selectionTextColor = null; protected static Color getSelectionBackground() { if (selectionBackground == null) { selectionBackground = ColorConstants.lightBlue; } return selectionBackground; } protected static Color getSelectionTextColor() { if (selectionTextColor == null) { selectionTextColor = Display.getCurrent().getSystemColor(SWT.COLOR_BLACK); } return selectionTextColor; } private Composite list; /** * A list of viewer elements (element type: <code>Object</code>). */ private List<Object> listMap = new ArrayList<Object>(); private List<CheckItem> items = new ArrayList<CheckItem>(); private List<ICheckStateListener> checkStateListeners = new ArrayList<ICheckStateListener>(); private CheckItem selectedItem = null; public CheckListViewer(Composite parent, int style) { list = new Composite(parent, style) { @Override public boolean setFocus() { return super.forceFocus(); } @Override public Point computeSize(int wHint, int hHint, boolean changed) { Point size; if (getItemCount() == 0) { size = new Point(0, 0); if (wHint != SWT.DEFAULT) size.x = wHint; if (hHint != SWT.DEFAULT) size.y = hHint; Rectangle trim = computeTrim(0, 0, size.x, size.y); size = new Point(trim.width, trim.height); } else { size = super.computeSize(wHint, hHint, changed); } return size; } }; // list.addListener( SWT.MouseDown, new Listener() { // public void handleEvent( Event event ) { // } // } ); list.addListener(SWT.KeyDown, new Listener() { public void handleEvent(Event event) { int keyCode = event.keyCode; int stateMask = event.stateMask; if (keyCode == SWT.TAB) { if (stateMask == SWT.MOD2) { list.traverse(SWT.TRAVERSE_TAB_PREVIOUS); } else if (stateMask == 0) { list.traverse(SWT.TRAVERSE_TAB_NEXT); } } else if (SWTUtils.matchKey(stateMask, keyCode, 0, SWT.CR)) { CheckItem item = getSelectedItem(); if (item != null) item.userOpen(event); } else if (SWTUtils.matchKey(stateMask, keyCode, 0, ' ')) { if (selectedItem != null) { selectedItem.setChecked(!selectedItem.isChecked()); fireChecked(selectedItem); } } else if (SWTUtils.matchKey(stateMask, keyCode, 0, SWT.ARROW_UP)) { if (selectedItem != null) { userSelectPrevious(selectedItem, event); } else if (!items.isEmpty()) { userSelectItem(0, event); } } else if (SWTUtils.matchKey(stateMask, keyCode, 0, SWT.ARROW_DOWN)) { if (selectedItem != null) { userSelectNext(selectedItem, event); } else if (!items.isEmpty()) { userSelectItem(0, event); } } } }); list.setTabList(new Control[0]); list.setBackground(parent.getBackground()); GridLayoutFactory.fillDefaults().spacing(0, 0).applyTo(list); //hookControl( list ); list.addDisposeListener(new DisposeListener() { public void widgetDisposed(DisposeEvent e) { handleDispose(e); } }); } protected void userSelectPrevious(CheckItem item, Event event) { int index = items.indexOf(item); if (index >= 1) { index--; userSelectItem(index, event); } } private void userSelectItem(int index, Event event) { setSelectedItem(items.get(index)); handleSelect(new SelectionEvent(event)); } protected void userSelectNext(CheckItem item, Event event) { int index = items.indexOf(item); if (index < listGetItemCount() - 1) { index++; userSelectItem(index, event); } } protected void setSelectedItem(CheckItem item) { if (item == this.selectedItem) return; this.selectedItem = item; for (CheckItem it : items) { it.setSelection(it == item); } } protected CheckItem getSelectedItem() { return selectedItem; } @Override public Control getControl() { return list; } protected Composite getListComposite() { return list; } protected List<CheckItem> getItems() { return items; } public int getItemCount() { return listGetItemCount(); } protected CheckItem listAdd(String string, Image image, int index) { CheckItem newItem = new CheckItem(this, list); GridDataFactory.fillDefaults().grab(true, false).applyTo(newItem.getControl()); newItem.setImage(image); newItem.setText(string); list.layout(); if (index < 0 || index >= listGetItemCount()) { items.add(newItem); } else { CheckItem oldItem = items.get(index); items.add(index, newItem); newItem.getControl().moveAbove(oldItem.getControl()); } return newItem; } protected void listDeselectAll() { setSelectedItem(null); // for ( CheckboxItem item : items ) { // item.setSelection( false ); // } } protected int listGetItemCount() { return items.size(); } protected int[] listGetSelectionIndices() { int total = listGetItemCount(); int[] counts = new int[total]; int num = 0; int j = 0; for (int i = 0; i < total; i++) { CheckItem item = items.get(i); if (item.isSelected()) { counts[j] = i; num++; j++; } } int[] ixs = new int[num]; System.arraycopy(counts, 0, ixs, 0, num); return ixs; } protected CheckItem listRemove(int index) { if (index < 0 || index >= listGetItemCount()) return null; CheckItem item = items.remove(index); if (item != null) item.dispose(); return item; } protected void listRemoveAll() { for (CheckItem item : items) { item.dispose(); } items.clear(); } protected void listSetItem(int index, String string, Image image) { if (index < 0 || index >= listGetItemCount()) return; CheckItem item = items.get(index); if (!item.isDisposed()) { item.setImage(image); item.setText(string); } } // protected void listSetItems( String[] labels ) { // if ( labels != null && labels.length > 0 ) { // for ( String label : labels ) { // listAdd( label, null, -1 ); // } // } // } protected void listSetSelection(int[] ixs) { listDeselectAll(); int total = listGetItemCount(); for (int index : ixs) { if (index >= 0 && index < total) { CheckItem item = items.get(index); if (selectedItem == null) selectedItem = item; item.setSelection(true); } } } protected void listShowSelection() { } public void reveal(Object element) { } public void addCheckStateListener(ICheckStateListener listener) { checkStateListeners.add(listener); } public boolean getChecked(Object element) { int index = getElementIndex(element); if (index >= 0) { CheckItem item = items.get(index); return !item.isDisposed() && item.isChecked(); } return false; } public Object[] getCheckedElements() { int count = getItemCount(); ArrayList<Object> checked = new ArrayList<Object>(count); for (int i = 0; i < count; i++) { CheckItem item = items.get(i); if (item.isChecked()) checked.add(listMap.get(i)); } return checked.toArray(); } // private int findIndex( Object element ) { // int total = listGetItemCount(); // for ( int i = 0; i < total; i++ ) { // if ( getElementAt( i ) == element ) // return i; // } // return -1; // } public void removeCheckStateListener(ICheckStateListener listener) { checkStateListeners.remove(listener); } public boolean setChecked(Object element, boolean state) { int index = getElementIndex(element); if (index >= 0) { CheckItem item = items.get(index); if (!item.isDisposed()) item.setChecked(state); } return false; } // protected Object findElementByCheckbox( Widget checkboxWidget ) { // int total = listGetItemCount(); // for ( int i = 0; i < total; i++ ) { // CheckboxItem item = items.get( i ); // if ( !item.isDisposed() ) { // if ( item.getCheckbox() == checkboxWidget ) { // return getElementAt( i ); // } // } // } // return null; // } protected void fireChecked(CheckItem item) { Object element = getElementAt(items.indexOf(item)); if (element == null) return; final CheckStateChangedEvent event = new CheckStateChangedEvent(this, element, item.isChecked()); for (final Object o : checkStateListeners.toArray()) { SafeRunner.run(new SafeRunnable() { public void run() throws Exception { ((ICheckStateListener) o).checkStateChanged(event); } }); } } @Override protected void preservingSelection(Runnable updateCode) { Map<Object, Boolean> checkStateMap = new HashMap<Object, Boolean>(); int total = listGetItemCount(); for (int i = 0; i < total; i++) { Object element = getElementAt(i); boolean checked = items.get(i).isChecked(); checkStateMap.put(element, checked); } super.preservingSelection(updateCode); total = listGetItemCount(); for (int i = 0; i < total; i++) { Object element = getElementAt(i); Boolean checked = checkStateMap.get(element); if (checked != null) { items.get(i).setChecked(checked); } } } /** * Adds the given elements to this list viewer. If this viewer does not have * a sorter, the elements are added at the end in the order given; otherwise * the elements are inserted at appropriate positions. * <p> * This method should be called (by the content provider) when elements have * been added to the model, in order to cause the viewer to accurately * reflect the model. This method only affects the viewer, not the model. * </p> * * @param elements * the elements to add */ public void add(Object[] elements) { assertElementsNotNull(elements); Object[] filtered = filter(elements); ILabelProvider labelProvider = (ILabelProvider) getLabelProvider(); for (int i = 0; i < filtered.length; i++) { Object element = filtered[i]; int ix = indexForElement(element); insertItem(labelProvider, element, ix); } } private void insertItem(ILabelProvider labelProvider, Object element, int index) { String label = getLabelProviderText(labelProvider, element); Image image = getImage(labelProvider, element); CheckItem item = listAdd(label, image, index); listMap.add(index, element); mapElement(element, item.getControl()); // must map it, since findItem only looks in map, if enabled } /** * Inserts the given element into this list viewer at the given position. If * this viewer has a sorter, the position is ignored and the element is * inserted at the correct position in the sort order. * <p> * This method should be called (by the content provider) when elements have * been added to the model, in order to cause the viewer to accurately * reflect the model. This method only affects the viewer, not the model. * </p> * * @param element * the element * @param position * a 0-based position relative to the model, or -1 to indicate * the last position * @since 3.3 */ public void insert(Object element, int position) { if (getComparator() != null || hasFilters()) { add(element); return; } insertItem((ILabelProvider) getLabelProvider(), element, position); } /** * Return the text for the element from the labelProvider. If it is null * then return the empty String. * * @param labelProvider * ILabelProvider * @param element * @return String. Return the emptyString if the labelProvider returns null * for the text. * @since 3.1 */ private String getLabelProviderText(ILabelProvider labelProvider, Object element) { String text = labelProvider.getText(element); if (text == null) { return "";//$NON-NLS-1$ } return text; } private Image getImage(ILabelProvider labelProvider, Object element) { return labelProvider.getImage(element); } /** * Adds the given element to this list viewer. If this viewer does not have * a sorter, the element is added at the end; otherwise the element is * inserted at the appropriate position. * <p> * This method should be called (by the content provider) when a single * element has been added to the model, in order to cause the viewer to * accurately reflect the model. This method only affects the viewer, not * the model. Note that there is another method for efficiently processing * the simultaneous addition of multiple elements. * </p> * * @param element * the element */ public void add(Object element) { add(new Object[] { element }); } /* * (non-Javadoc) Method declared on StructuredViewer. Since SWT.List doesn't * use items we always return the List itself. */ protected Widget doFindInputItem(Object element) { if (element != null && equals(element, getRoot())) { return getControl(); } return null; } /* * (non-Javadoc) Method declared on StructuredViewer. Since SWT.List doesn't * use items we always return the List itself. */ protected Widget doFindItem(Object element) { if (element != null) { int index = getElementIndex(element); if (index >= 0) { return items.get(index).getControl(); } // if (listMapContains(element)) { // return getControl(); // } } return null; } /* * (non-Javadoc) Method declared on StructuredViewer. */ protected void doUpdateItem(Widget data, Object element, boolean fullMap) { if (element != null) { int ix = getElementIndex(element); if (ix >= 0) { ILabelProvider labelProvider = (ILabelProvider) getLabelProvider(); String label = getLabelProviderText(labelProvider, element); Image image = getImage(labelProvider, element); listSetItem(ix, label, image); } } } /** * Returns the element with the given index from this list viewer. Returns * <code>null</code> if the index is out of range. * * @param index * the zero-based index * @return the element at the given index, or <code>null</code> if the index * is out of range */ public Object getElementAt(int index) { if (index >= 0 && index < listMap.size()) { return listMap.get(index); } return null; } /** * The list viewer implementation of this <code>Viewer</code> framework * method returns the label provider, which in the case of list viewers will * be an instance of <code>ILabelProvider</code>. */ public IBaseLabelProvider getLabelProvider() { return super.getLabelProvider(); } /* * (non-Javadoc) Method declared on Viewer. */ /* * (non-Javadoc) Method declared on StructuredViewer. */ protected List getSelectionFromWidget() { int[] ixs = listGetSelectionIndices(); List<Object> list = new ArrayList<Object>(ixs.length); for (int i = 0; i < ixs.length; i++) { Object e = getElementAt(ixs[i]); if (e != null) { list.add(e); } } return list; } /** * @param element * the element to insert * @return the index where the item should be inserted. */ protected int indexForElement(Object element) { ViewerComparator comparator = getComparator(); if (comparator == null) { return listGetItemCount(); } int count = listGetItemCount(); int min = 0, max = count - 1; while (min <= max) { int mid = (min + max) / 2; Object data = listMap.get(mid); int compare = comparator.compare(this, data, element); if (compare == 0) { // find first item > element while (compare == 0) { ++mid; if (mid >= count) { break; } data = listMap.get(mid); compare = comparator.compare(this, data, element); } return mid; } if (compare < 0) { min = mid + 1; } else { max = mid - 1; } } return min; } /* * (non-Javadoc) Method declared on Viewer. */ protected void inputChanged(Object input, Object oldInput) { listMap.clear(); Object[] children = getSortedChildren(getRoot()); int size = children.length; listRemoveAll(); //String[] labels = new String[size]; for (int i = 0; i < size; i++) { Object el = children[i]; String label = getLabelProviderText((ILabelProvider) getLabelProvider(), el); Image image = getImage((ILabelProvider) getLabelProvider(), el); CheckItem item = listAdd(label, image, -1); listMap.add(el); mapElement(el, item.getControl()); // must map it, since findItem only looks in map, if enabled } //listSetItems(labels); } /* * (non-Javadoc) Method declared on StructuredViewer. */ protected void internalRefresh(Object element) { Control list = getControl(); if (element == null || equals(element, getRoot())) { // the parent if (listMap != null) { listMap.clear(); } unmapAllElements(); List selection = getSelectionFromWidget(); int topIndex = -1; if (selection == null || selection.isEmpty()) { topIndex = listGetTopIndex(); } list.setRedraw(false); listRemoveAll(); Object[] children = getSortedChildren(getRoot()); //String[] items = new String[children.length]; ILabelProvider labelProvider = (ILabelProvider) getLabelProvider(); for (int i = 0; i < children.length; i++) { Object el = children[i]; String label = getLabelProviderText(labelProvider, el); Image image = getImage(labelProvider, el); CheckItem item = listAdd(label, image, -1); listMap.add(el); mapElement(el, item.getControl()); // must map it, since findItem only looks in map, if enabled } //listSetItems(items); list.setRedraw(true); if (topIndex == -1) { setSelectionToWidget(selection, false); } else { listSetTopIndex(Math.min(topIndex, children.length)); } } else { doUpdateItem(list, element, true); } } /** * Returns the index of the item currently at the top of the viewable area. * <p> * Default implementation returns -1. * </p> * * @return index, -1 for none * @since 3.3 */ protected int listGetTopIndex() { return -1; } /** * Sets the index of the item to be at the top of the viewable area. * <p> * Default implementation does nothing. * </p> * * @param index * the given index. -1 for none. index will always refer to a * valid index. * @since 3.3 */ protected void listSetTopIndex(int index) { } /** * Removes the given elements from this list viewer. * * @param elements * the elements to remove */ private void internalRemove(final Object[] elements) { Object input = getInput(); for (int i = 0; i < elements.length; ++i) { if (equals(elements[i], input)) { setInput(null); return; } int ix = getElementIndex(elements[i]); if (ix >= 0) { CheckItem item = listRemove(ix); listMap.remove(ix); unmapElement(elements[i], item.getControl()); } } } /** * Removes the given elements from this list viewer. The selection is * updated if required. * <p> * This method should be called (by the content provider) when elements have * been removed from the model, in order to cause the viewer to accurately * reflect the model. This method only affects the viewer, not the model. * </p> * * @param elements * the elements to remove */ public void remove(final Object[] elements) { assertElementsNotNull(elements); if (elements.length == 0) { return; } preservingSelection(new Runnable() { public void run() { internalRemove(elements); } }); } /** * Removes the given element from this list viewer. The selection is updated * if necessary. * <p> * This method should be called (by the content provider) when a single * element has been removed from the model, in order to cause the viewer to * accurately reflect the model. This method only affects the viewer, not * the model. Note that there is another method for efficiently processing * the simultaneous removal of multiple elements. * </p> * * @param element * the element */ public void remove(Object element) { remove(new Object[] { element }); } /** * The list viewer implementation of this <code>Viewer</code> framework * method ensures that the given label provider is an instance of * <code>ILabelProvider</code>. <b>The optional interfaces * {@link IColorProvider} and {@link IFontProvider} have no effect for this * type of viewer</b> */ public void setLabelProvider(IBaseLabelProvider labelProvider) { Assert.isTrue(labelProvider instanceof ILabelProvider); super.setLabelProvider(labelProvider); } /* * (non-Javadoc) Method declared on StructuredViewer. */ protected void setSelectionToWidget(List in, boolean reveal) { if (in == null || in.size() == 0) { // clear selection listDeselectAll(); } else { int n = in.size(); int[] ixs = new int[n]; int count = 0; for (int i = 0; i < n; ++i) { Object el = in.get(i); int ix = getElementIndex(el); if (ix >= 0) { ixs[count++] = ix; } } if (count < n) { System.arraycopy(ixs, 0, ixs = new int[count], 0, count); } listSetSelection(ixs); if (reveal) { listShowSelection(); } } } /** * Returns the index of the given element in listMap, or -1 if the element * cannot be found. As of 3.3, uses the element comparer if available. * * @param element * @return the index */ protected int getElementIndex(Object element) { IElementComparer comparer = getComparer(); if (comparer == null) { return listMap.indexOf(element); } int size = listMap.size(); for (int i = 0; i < size; i++) { if (comparer.equals(element, listMap.get(i))) return i; } return -1; } // /** // * @param element // * @return true if listMap contains the given element // * // * @since 3.3 // */ // private boolean listMapContains(Object element) { // return getElementIndex(element) != -1; // } }