Mercurial > projects > dwt2
diff org.eclipse.jface/src/org/eclipse/jface/viewers/CheckboxTableViewer.d @ 12:bc29606a740c
Added dwt-addons in original directory structure of eclipse.org
author | Frank Benoit <benoit@tionex.de> |
---|---|
date | Sat, 14 Mar 2009 18:23:29 +0100 |
parents | |
children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.eclipse.jface/src/org/eclipse/jface/viewers/CheckboxTableViewer.d Sat Mar 14 18:23:29 2009 +0100 @@ -0,0 +1,454 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + * Port to the D programming language: + * Frank Benoit <benoit@tionex.de> + *******************************************************************************/ +module org.eclipse.jface.viewers.CheckboxTableViewer; + +import org.eclipse.jface.viewers.ICheckable; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.jface.viewers.ICheckStateListener; +import org.eclipse.jface.viewers.CheckStateChangedEvent; +import org.eclipse.jface.viewers.TableLayout; +import org.eclipse.jface.viewers.ColumnWeightData; +import org.eclipse.jface.viewers.CustomHashtable; + + +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Table; +import org.eclipse.swt.widgets.TableColumn; +import org.eclipse.swt.widgets.TableItem; +import org.eclipse.swt.widgets.Widget; +import org.eclipse.core.runtime.Assert; +import org.eclipse.core.runtime.ListenerList; +import org.eclipse.jface.util.SafeRunnable; + +import java.lang.all; +import java.util.List; +import java.util.ArrayList; +import java.util.Set; + +/** + * A concrete viewer based on an SWT <code>Table</code> + * control with checkboxes on each node. + * <p> + * This class is not intended to be subclassed outside the viewer framework. + * It is designed to be instantiated with a pre-existing SWT table control and configured + * with a domain-specific content provider, label provider, element filter (optional), + * and element sorter (optional). + * </p> + * @noextend This class is not intended to be subclassed by clients. + */ +public class CheckboxTableViewer : TableViewer, ICheckable { + alias TableViewer.preservingSelection preservingSelection; + + /** + * List of check state listeners (element type: <code>ICheckStateListener</code>). + */ + private ListenerList checkStateListeners; + + /** + * Creates a table viewer on a newly-created table control under the given parent. + * The table control is created using the SWT style bits: + * <code>SWT.CHECK</code> and <code>SWT.BORDER</code>. + * The table has one column. + * The viewer has no input, no content provider, a default label provider, + * no sorter, and no filters. + * <p> + * This is equivalent to calling <code>new CheckboxTableViewer(parent, SWT.BORDER)</code>. + * See that constructor for more details. + * </p> + * + * @param parent the parent control + * + * @deprecated use newCheckList(Composite, int) or new CheckboxTableViewer(Table) + * instead (see below for details) + */ + public this(Composite parent) { + this(parent, SWT.BORDER); + } + + /** + * Creates a table viewer on a newly-created table control under the given parent. + * The table control is created using the given SWT style bits, plus the + * <code>SWT.CHECK</code> style bit. + * The table has one column. + * The viewer has no input, no content provider, a default label provider, + * no sorter, and no filters. + * <p> + * This also adds a <code>TableColumn</code> for the single column, + * and sets a <code>TableLayout</code> on the table which sizes the column to fill + * the table for its initial sizing, but does nothing on subsequent resizes. + * </p> + * <p> + * If the caller just needs to show a single column with no header, + * it is preferable to use the <code>newCheckList</code> factory method instead, + * since SWT properly handles the initial sizing and subsequent resizes in this case. + * </p> + * <p> + * If the caller adds its own columns, uses <code>Table.setHeadersVisible(true)</code>, + * or needs to handle dynamic resizing of the table, it is recommended to + * create the <code>Table</code> itself, specifying the <code>SWT.CHECK</code> style bit + * (along with any other style bits needed), and use <code>new CheckboxTableViewer(Table)</code> + * rather than this constructor. + * </p> + * + * @param parent the parent control + * @param style SWT style bits + * + * @deprecated use newCheckList(Composite, int) or new CheckboxTableViewer(Table) + * instead (see above for details) + */ + public this(Composite parent, int style) { + this(createTable(parent, style)); + } + + /** + * Creates a table viewer on a newly-created table control under the given parent. + * The table control is created using the given SWT style bits, plus the + * <code>SWT.CHECK</code> style bit. + * The table shows its contents in a single column, with no header. + * The viewer has no input, no content provider, a default label provider, + * no sorter, and no filters. + * <p> + * No <code>TableColumn</code> is added. SWT does not require a + * <code>TableColumn</code> if showing only a single column with no header. + * SWT correctly handles the initial sizing and subsequent resizes in this case. + * + * @param parent the parent control + * @param style SWT style bits + * + * @since 2.0 + * @return CheckboxTableViewer + */ + public static CheckboxTableViewer newCheckList(Composite parent, int style) { + Table table = new Table(parent, SWT.CHECK | style); + return new CheckboxTableViewer(table); + } + + /** + * Creates a table viewer on the given table control. + * The <code>SWT.CHECK</code> style bit must be set on the given table control. + * The viewer has no input, no content provider, a default label provider, + * no sorter, and no filters. + * + * @param table the table control + */ + public this(Table table) { + super(table); + checkStateListeners = new ListenerList(); + } + + /* (non-Javadoc) + * Method declared on ICheckable. + */ + public void addCheckStateListener(ICheckStateListener listener) { + checkStateListeners.add(cast(Object)listener); + } + + /** + * Creates a new table control with one column. + * + * @param parent the parent control + * @param style style bits + * @return a new table control + */ + protected static Table createTable(Composite parent, int style) { + Table table = new Table(parent, SWT.CHECK | style); + + // Although this table column is not needed, and can cause resize problems, + // it can't be removed since this would be a breaking change against R1.0. + // See bug 6643 for more details. + new TableColumn(table, SWT.NONE); + TableLayout layout = new TableLayout(); + layout.addColumnData(new ColumnWeightData(100)); + table.setLayout(layout); + + return table; + } + + /** + * Notifies any check state listeners that a check state changed has been received. + * Only listeners registered at the time this method is called are notified. + * + * @param event a check state changed event + * + * @see ICheckStateListener#checkStateChanged + */ + private void fireCheckStateChanged(CheckStateChangedEvent event) { + Object[] array = checkStateListeners.getListeners(); + for (int i = 0; i < array.length; i++) { + SafeRunnable.run( dgSafeRunnable( (ICheckStateListener l, CheckStateChangedEvent event_) { + l.checkStateChanged(event_); + }, cast(ICheckStateListener) array[i], event )); + } + } + + /* (non-Javadoc) + * Method declared on ICheckable. + */ + public bool getChecked(Object element) { + Widget widget = findItem(element); + if ( auto ti = cast(TableItem) widget ) { + return ti.getChecked(); + } + return false; + } + + /** + * Returns a list of elements corresponding to checked table items in this + * viewer. + * <p> + * This method is typically used when preserving the interesting + * state of a viewer; <code>setCheckedElements</code> is used during the restore. + * </p> + * + * @return the array of checked elements + * @see #setCheckedElements + */ + public Object[] getCheckedElements() { + TableItem[] children = getTable().getItems(); + ArrayList v = new ArrayList(children.length); + for (int i = 0; i < children.length; i++) { + TableItem item = children[i]; + if (item.getChecked()) { + v.add(item.getData()); + } + } + return v.toArray(); + } + + /** + * Returns the grayed state of the given element. + * + * @param element the element + * @return <code>true</code> if the element is grayed, + * and <code>false</code> if not grayed + */ + public bool getGrayed(Object element) { + Widget widget = findItem(element); + if ( auto ti = cast(TableItem) widget ) { + return ti.getGrayed(); + } + return false; + } + + /** + * Returns a list of elements corresponding to grayed nodes in this + * viewer. + * <p> + * This method is typically used when preserving the interesting + * state of a viewer; <code>setGrayedElements</code> is used during the restore. + * </p> + * + * @return the array of grayed elements + * @see #setGrayedElements + */ + public Object[] getGrayedElements() { + TableItem[] children = getTable().getItems(); + ArrayList v = new ArrayList(children.length); + for (int i = 0; i < children.length; i++) { + TableItem item = children[i]; + if (item.getGrayed()) { + v.add(item.getData()); + } + } + return v.toArray(); + } + + /* (non-Javadoc) + * Method declared on StructuredViewer. + */ + public override void handleSelect(SelectionEvent event) { + if (event.detail is SWT.CHECK) { + super.handleSelect(event); // this will change the current selection + + TableItem item = cast(TableItem) event.item; + Object data = item.getData(); + if (data !is null) { + fireCheckStateChanged(new CheckStateChangedEvent(this, data, + item.getChecked())); + } + } else { + super.handleSelect(event); + } + } + + /* (non-Javadoc) + * Method declared on Viewer. + */ + protected override void preservingSelection(Runnable updateCode) { + + TableItem[] children = getTable().getItems(); + CustomHashtable checked = newHashtable(children.length * 2 + 1); + CustomHashtable grayed = newHashtable(children.length * 2 + 1); + + for (int i = 0; i < children.length; i++) { + TableItem item = children[i]; + Object data = item.getData(); + if (data !is null) { + if (item.getChecked()) { + checked.put(data, data); + } + if (item.getGrayed()) { + grayed.put(data, data); + } + } + } + + super.preservingSelection(updateCode); + + children = getTable().getItems(); + for (int i = 0; i < children.length; i++) { + TableItem item = children[i]; + Object data = item.getData(); + if (data !is null) { + item.setChecked(checked.containsKey(data)); + item.setGrayed(grayed.containsKey(data)); + } + } + } + + /* (non-Javadoc) + * Method declared on ICheckable. + */ + public void removeCheckStateListener(ICheckStateListener listener) { + checkStateListeners.remove(cast(Object)listener); + } + + /** + * Sets to the given value the checked state for all elements in this viewer. + * Does not fire events to check state listeners. + * + * @param state <code>true</code> if the element should be checked, + * and <code>false</code> if it should be unchecked + */ + public void setAllChecked(bool state) { + TableItem[] children = getTable().getItems(); + for (int i = 0; i < children.length; i++) { + TableItem item = children[i]; + item.setChecked(state); + } + } + + /** + * Sets to the given value the grayed state for all elements in this viewer. + * + * @param state <code>true</code> if the element should be grayed, + * and <code>false</code> if it should be ungrayed + */ + public void setAllGrayed(bool state) { + TableItem[] children = getTable().getItems(); + for (int i = 0; i < children.length; i++) { + TableItem item = children[i]; + item.setGrayed(state); + } + } + + /* (non-Javadoc) + * Method declared on ICheckable. + */ + public bool setChecked(Object element, bool state) { + Assert.isNotNull(element); + Widget widget = findItem(element); + if ( auto ti = cast(TableItem) widget ) { + ti.setChecked(state); + return true; + } + return false; + } + + /** + * Sets which nodes are checked in this viewer. + * The given list contains the elements that are to be checked; + * all other nodes are to be unchecked. + * Does not fire events to check state listeners. + * <p> + * This method is typically used when restoring the interesting + * state of a viewer captured by an earlier call to <code>getCheckedElements</code>. + * </p> + * + * @param elements the list of checked elements (element type: <code>Object</code>) + * @see #getCheckedElements + */ + public void setCheckedElements(Object[] elements) { + assertElementsNotNull(elements); + CustomHashtable set = newHashtable(elements.length * 2 + 1); + for (int i = 0; i < elements.length; ++i) { + set.put(elements[i], elements[i]); + } + TableItem[] items = getTable().getItems(); + for (int i = 0; i < items.length; ++i) { + TableItem item = items[i]; + Object element = item.getData(); + if (element !is null) { + bool check = set.containsKey(element); + // only set if different, to avoid flicker + if (item.getChecked() !is check) { + item.setChecked(check); + } + } + } + } + + /** + * Sets the grayed state for the given element in this viewer. + * + * @param element the element + * @param state <code>true</code> if the item should be grayed, + * and <code>false</code> if it should be ungrayed + * @return <code>true</code> if the element is visible and the gray + * state could be set, and <code>false</code> otherwise + */ + public bool setGrayed(Object element, bool state) { + Assert.isNotNull(element); + Widget widget = findItem(element); + if ( auto ti = cast(TableItem) widget ) { + ti.setGrayed(state); + return true; + } + return false; + } + + /** + * Sets which nodes are grayed in this viewer. + * The given list contains the elements that are to be grayed; + * all other nodes are to be ungrayed. + * <p> + * This method is typically used when restoring the interesting + * state of a viewer captured by an earlier call to <code>getGrayedElements</code>. + * </p> + * + * @param elements the array of grayed elements + * + * @see #getGrayedElements + */ + public void setGrayedElements(Object[] elements) { + assertElementsNotNull(elements); + CustomHashtable set = newHashtable(elements.length * 2 + 1); + for (int i = 0; i < elements.length; ++i) { + set.put(elements[i], elements[i]); + } + TableItem[] items = getTable().getItems(); + for (int i = 0; i < items.length; ++i) { + TableItem item = items[i]; + Object element = item.getData(); + if (element !is null) { + bool gray = set.containsKey(element); + // only set if different, to avoid flicker + if (item.getGrayed() !is gray) { + item.setGrayed(gray); + } + } + } + } +}