projects/dwt-addons: dwtx/jface/viewers/StructuredViewer.d comparison

comparison dwtx/jface/viewers/StructuredViewer.d @ 104:04b47443bb01

Reworked the collection uses to make use of a wrapper collection that is compatible to the Java Collections. These new wrappers now use the tango.util.containers instead of the tango.util.collections.

author	Frank Benoit <benoit@tionex.de>
date	Thu, 07 Aug 2008 15:01:33 +0200
parents	7ffeace6c47f
children

comparison

equal deleted inserted replaced

-:2d6540440fe6
+:04b47443bb01
 import dwtx.jface.viewers.ILabelProvider;
 import dwtx.jface.viewers.IStructuredContentProvider;
 import dwtx.jface.viewers.StructuredSelection;
 import dwtx.jface.viewers.IStructuredSelection;
-import tango.util.collection.ArraySeq;
-import tango.util.collection.model.Seq;
-import tango.util.collection.model.SeqView;
 import dwt.custom.TableTreeItem;
 import dwt.dnd.DragSource;
 import dwt.dnd.DragSourceListener;
 import dwt.dnd.DropTarget;
 import dwtx.jface.util.IOpenEventListener;
 import dwtx.jface.util.OpenStrategy;
 import dwtx.jface.util.SafeRunnable;
 import dwt.dwthelper.utils;
+import dwtx.dwtxhelper.Collection;
 import dwt.dwthelper.Runnable;
 /**
 * Abstract base implementation for structure-oriented viewers (trees, lists,
 * tables). Supports custom sorting, filtering, and rendering.
 /**
 * This viewer's filters (element type: <code>ViewerFilter</code>).
 * <code>null</code> means there are no filters.
 */
-private Seq!(ViewerFilter) filters;
+private List filters;
 /**
 * Indicates whether a selection change is in progress on this viewer.
 *
 * @see #setSelection(ISelection, bool)
 *            a viewer filter
 * @see StructuredViewer#setFilters(ViewerFilter[])
 */
 public void addFilter(ViewerFilter filter) {
 if (filters is null) {
-filters = new ArraySeq!(ViewerFilter);
+filters = new ArrayList();
 }
-filters.append(filter);
+filters.add(filter);
 refresh();
 }
 /**
 * Asserts that the given array of elements is itself non- <code>null</code>
 *            the elements to filter
 * @return only the elements which all filters accept
 */
 protected Object[] filter(Object[] elements) {
 if (filters !is null) {
-ArraySeq!(Object) filtered = new ArraySeq!(Object);
+ArrayList filtered = new ArrayList(elements.length);
-filtered.capacity(elements.length);
 Object root = getRoot();
 for (int i = 0; i < elements.length; i++) {
 bool add = true;
 for (int j = 0; j < filters.size(); j++) {
 add = (cast(ViewerFilter) filters.get(j)).select(this, root, elements[i]);
 if (!add) {
 break;
 }
 }
 if (add) {
-filtered.append(elements[i]);
+filtered.add(elements[i]);
 }
 }
 return filtered.toArray();
 }
 return elements;
 * @see IDoubleClickListener#doubleClick
 */
 protected void fireDoubleClick(DoubleClickEvent event) {
 Object[] listeners = doubleClickListeners.getListeners();
 for (int i = 0; i < listeners.length; ++i) {
-SafeRunnable.run(new class(cast(IDoubleClickListener) listeners[i], event) SafeRunnable {
+SafeRunnable.run( dgSafeRunnable( (IDoubleClickListener l, DoubleClickEvent event_){
-IDoubleClickListener l;
+l.doubleClick(event_);
-DoubleClickEvent event_;
+}, cast(IDoubleClickListener) listeners[i], event));
-this(IDoubleClickListener a,DoubleClickEvent b){
-l = a;
-event_=b;
-}
-public void run() {
-l.doubleClick(event_);
-}
-});
 }
 }
 package void fireDoubleClick_package(DoubleClickEvent event) {
 fireDoubleClick(event);
 }
 * @see IOpenListener#open(OpenEvent)
 */
 protected void fireOpen(OpenEvent event) {
 Object[] listeners = openListeners.getListeners();
 for (int i = 0; i < listeners.length; ++i) {
-SafeRunnable.run(new class(cast(IOpenListener) listeners[i],event) SafeRunnable {
+SafeRunnable.run( dgSafeRunnable( (IOpenListener l,OpenEvent event_){
-IOpenListener l;
+l.open(event_);
-OpenEvent event_;
+}, cast(IOpenListener) listeners[i],event));
-this(IOpenListener a, OpenEvent b){
-l = a;
-event_=b;
-}
-public void run() {
-l.open(event_);
-}
-});
 }
 }
 package void fireOpen_package(OpenEvent event) {
 fireOpen(event);
 }
 * @see #addPostSelectionChangedListener(ISelectionChangedListener)
 */
 protected void firePostSelectionChanged(SelectionChangedEvent event) {
 Object[] listeners = postSelectionChangedListeners.getListeners();
 for (int i = 0; i < listeners.length; ++i) {
-SafeRunnable.run(new class(cast(ISelectionChangedListener) listeners[i],event) SafeRunnable {
+SafeRunnable.run( dgSafeRunnable( (ISelectionChangedListener l, SelectionChangedEvent event_){
-ISelectionChangedListener l;
+l.selectionChanged(event_);
-SelectionChangedEvent event_;
+},cast(ISelectionChangedListener) listeners[i],event));
-this(ISelectionChangedListener a,SelectionChangedEvent b){
-l = a;
-event_=b;
-}
-public void run() {
-l.selectionChanged(event_);
-}
-});
 }
 }
 /**
 * Returns the comparer to use for comparing elements, or
 * @return a filtered array of child elements
 */
 protected Object[] getFilteredChildren(Object parent) {
 Object[] result = getRawChildren(parent);
 if (filters !is null) {
-foreach (f;filters) {
+for (Iterator iter = filters.iterator(); iter.hasNext();) {
+ViewerFilter f = cast(ViewerFilter) iter.next();
 result = f.filter(this, parent, result);
 }
 }
 return result;
 }
 */
 public ViewerFilter[] getFilters() {
 if (filters is null) {
 return new ViewerFilter[0];
 }
-return filters.toArray();
+return arraycast!(ViewerFilter)(filters.toArray());
 }
 /**
 * Returns the item at the given display-relative coordinates, or
 * <code>null</code> if there is no item at that location or
 public override ISelection getSelection() {
 Control control = getControl();
 if (control is null || control.isDisposed()) {
 return StructuredSelection.EMPTY;
 }
-auto list = getSelectionFromWidget();
+List list = getSelectionFromWidget();
 return new StructuredSelection(list, comparer);
 }
 /**
 * Retrieves the selection, as a <code>List</code>, from the underlying
 * widget.
 *
 * @return the list of selected elements
 */
-protected abstract SeqView!(Object) getSelectionFromWidget();
+protected abstract List getSelectionFromWidget();
-package SeqView!(Object) getSelectionFromWidget_package(){
+package List getSelectionFromWidget_package(){
 return getSelectionFromWidget();
 }
 /**
 * Returns the sorted and filtered set of children of the given element. The
 if (widgetOrWidgets !is item) {
 elementMap.put(element, new ArrayWrapperT!(Widget)( [ w, item ] ));
 }
 } else {
 Widget[] widgets = (cast(ArrayWrapperT!(Widget)) widgetOrWidgets).array;
-int indexOfItem = -1;
+int indexOfItem = Arrays.asList(widgets).indexOf(item);
-foreach( idx, w; widgets ){
-if( w == item ){
-indexOfItem = idx;
-break;
-}
-}
 if (indexOfItem is -1) {
 int length_ = widgets.length;
 System.arraycopy(widgets, 0,
 widgets = new Widget[length_ + 1], 0, length_);
 widgets[length_] = item;
-elementMap.put(element, new ArrayWrapperT!(Widget)(widgets));
+elementMap.put(element, new ArrayWrapperObject(widgets));
 }
 }
 }
 }
 if (sorter !is null && sorter.isSorterProperty(element, property)) {
 return true;
 }
 if (filters !is null) {
-foreach( filter; filters ){
+for (int i = 0, n = filters.size(); i < n; ++i) {
+ViewerFilter filter = cast(ViewerFilter) filters.get(i);
 if (filter.isFilterProperty(element, property)) {
 return true;
 }
 }
 }
 *
 * @param element
 *            the element
 */
 public void refresh(Object element) {
-preservingSelection(new class(element) Runnable {
+preservingSelection( dgRunnable( (Object element_){
-Object element_;
+internalRefresh(element_);
-this(Object a){
+}, element ));
-element_ = a;
-}
-public void run() {
-internalRefresh(element_);
-}
-});
 }
 /**
 * Refreshes this viewer starting with the given element. Labels are updated
 * as described in <code>refresh(bool updateLabels)</code>.
 *            that labels for existing elements are unchanged.
 *
 * @since 2.0
 */
 public void refresh(Object element, bool updateLabels) {
-preservingSelection(new class(element, updateLabels) Runnable {
+preservingSelection( dgRunnable( (Object element_, bool updateLabels_){
-Object element_;
+internalRefresh(element_, updateLabels_);
-bool updateLabels_;
+},element, updateLabels));
-this(Object a, bool b){
-element_ = a;
-updateLabels_ = b;
-}
-public void run() {
-internalRefresh(element_, updateLabels_);
-}
-});
 }
 /**
 *
 * Refreshes the given item with the given element. Calls
 public void removeFilter(ViewerFilter filter) {
 Assert.isNotNull(filter);
 if (filters !is null) {
 // Note: can't use List.remove(Object). Use identity comparison
 // instead.
-int delIdx = 0;
+for (Iterator i = filters.iterator(); i.hasNext();) {
-foreach( o; filters ){
+Object o = i.next();
 if (o is filter) {
-filters.removeAt(delIdx);
+i.remove();
 refresh();
 if (filters.size() is 0) {
 filters = null;
 }
 return;
 }
-delIdx++;
 }
 }
 }
 /**
 */
 public void setFilters(ViewerFilter[] filters) {
 if (filters.length is 0) {
 resetFilters();
 } else {
-auto tmp = new ArraySeq!(ViewerFilter);
+this.filters = new ArrayList(Arrays.asList(filters));
-foreach( f; filters ){
-tmp.append(f);
-}
-this.filters = tmp;
 refresh();
 }
 }
 /**
 *            or <code>null</code> if the selection is to be cleared
 * @param reveal
 *            <code>true</code> if the selection is to be made visible,
 *            and <code>false</code> otherwise
 */
-protected abstract void setSelectionToWidget(SeqView!(Object) l, bool reveal);
+protected abstract void setSelectionToWidget(List l, bool reveal);
 /**
 * Converts the selection to a <code>List</code> and calls
 * <code>setSelectionToWidget(List, bool)</code>. The selection is
 * expected to be an <code>IStructuredSelection</code> of elements. If
 */
 protected void setSelectionToWidget(ISelection selection, bool reveal) {
 if ( auto ss = cast(IStructuredSelection) selection ) {
 setSelectionToWidget(ss.toList(), reveal);
 } else {
-setSelectionToWidget(cast(SeqView!(Object)) null, reveal);
+setSelectionToWidget(cast(List) null, reveal);
 }
 }
 /**
 * Sets this viewer's sorter and triggers refiltering and resorting of this
 if (item is widgetOrWidgets) {
 elementMap.remove(element);
 }
 } else {
 Widget[] widgets = ( cast(ArrayWrapperT!(Widget)) widgetOrWidgets).array;
-int indexOfItem = -1;
+int indexOfItem = Arrays.asList(widgets).indexOf(item);
-foreach( idx, w; widgets ){
-if( w == item ){
-indexOfItem = idx;
-break;
-}
-}
 if (indexOfItem is -1) {
 return;
 }
 int length = widgets.length;
 if (indexOfItem is 0) {
 if(length is 1) {
 elementMap.remove(element);
 } else {
 Widget[] updatedWidgets = new Widget[length - 1];
 System.arraycopy(widgets, 1, updatedWidgets, 0, length -1 );
-elementMap.put(element, new ArrayWrapperT!(Widget)( updatedWidgets));
+elementMap.put(element, new ArrayWrapperObject( updatedWidgets));
 }
 } else {
 Widget[] updatedWidgets = new Widget[length - 1];
 System.arraycopy(widgets, 0, updatedWidgets, 0, indexOfItem);
 System.arraycopy(widgets, indexOfItem + 1, updatedWidgets, indexOfItem, length - indexOfItem - 1);
-elementMap.put(element, new ArrayWrapperT!(Widget)(updatedWidgets));
+elementMap.put(element, new ArrayWrapperObject(updatedWidgets));
 }
 }
 }
 }
 // flag to indicate that a full refresh took place. See bug 102440.
 private bool refreshOccurred;
 /**
 * Updates the given elements' presentation when one or more of their
 * properties change. Only the given elements are updated.
 * <p>
 * This does not handle structural changes (e.g. addition or removal of
 bool mayExitEarly = !refreshOccurred;
 for (int i = 0; i < items.length; i++) {
 internalUpdate(items[i], element, properties);
 if (mayExitEarly && refreshOccurred) {
 // detected a change from refreshOccurred is false to refreshOccurred is true
 return;
 }
 }
 }
 break;
 }
 }
 }
 if (needsRefilter_) {
-preservingSelection(new class Runnable {
+preservingSelection(dgRunnable( {
-public void run() {
+internalRefresh(getRoot());
-internalRefresh(getRoot());
+refreshOccurred = true;
-refreshOccurred = true;
+}));
-}
-});
 return;
 }
 bool needsUpdate;
 if (properties is null) {

Mercurial > projects > dwt-addons

comparison dwtx/jface/viewers/StructuredViewer.d @ 104:04b47443bb01