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

comparison dwtx/jface/viewers/AbstractTreeViewer.d @ 70:46a6e0e6ccd4

Merge with d-fied sources of 3.4M7

author	Frank Benoit <benoit@tionex.de>
date	Thu, 22 May 2008 01:36:46 +0200
parents	a6683645b0d7
children	4878bef4a38e

comparison

equal deleted inserted replaced

-:07b9d96fd764
+:46a6e0e6ccd4
 /*******************************************************************************
-* Copyright (c) 2000, 2007 IBM Corporation and others.
+* 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
 *     Tom Schindl <tom.schindl@bestsolution.at> - bug 153993, bug 167323, bug 175192
+*     Lasse Knudsen, bug 205700
+*     Micah Hainline, bug 210448
+*     Michael Schneider, bug 210747
+*     Bruce Sutton, bug 221768
+*     Matthew Hall, bug 221988
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
 module dwtx.jface.viewers.AbstractTreeViewer;
 *            the child elements to add
 */
 public void add(Object parentElementOrTreePath, Object[] childElements) {
 Assert.isNotNull(parentElementOrTreePath);
 assertElementsNotNull(childElements);
-if (isBusy())
+if (checkBusy())
 return;
 Widget[] widgets = internalFindItems(parentElementOrTreePath);
 // If parent hasn't been realized yet, just ignore the add.
 if (widgets.length is 0) {
 return;
 ViewerComparator comparator = getComparator();
 TreePath parentPath = internalGetSorterParentPath(widget, comparator);
 Item[] items = getChildren(widget);
-// As the items are sorted already we optimize for a
-// start position
-int lastInsertion = 0;
 // Optimize for the empty case
 if (items.length is 0) {
 for (int i = 0; i < elements.length; i++) {
 createTreeItem(widget, elements[i], -1);
 }
 return;
 }
-for (int i = 0; i < elements.length; i++) {
+// Optimize for no comparator
-bool newItem = true;
+if (comparator is null) {
-Object element = elements[i];
+for (int i = 0; i < elements.length; i++) {
-int index;
+Object element = elements[i];
-if (comparator is null) {
 if (itemExists(items, element)) {
 internalRefresh(element);
-newItem = false;
+} else {
-}
+createTreeItem(widget, element, -1);
-index = -1;
+}
+}
+return;
+}
+// As the items are sorted already we optimize for a
+// start position. This is the insertion position relative to the
+// original item array.
+int indexInItems = 0;
+// Count of elements we have added. See bug 205700 for why this is needed.
+int newItems = 0;
+elementloop: for (int i = 0; i < elements.length; i++) {
+Object element = elements[i];
+// update the index relative to the original item array
+indexInItems = insertionPosition(items, comparator,
+indexInItems, element, parentPath);
+if (indexInItems is items.length) {
+createTreeItem(widget, element, -1);
+newItems++;
 } else {
-lastInsertion = insertionPosition(items, comparator,
+// Search for an item for the element. The comparator might
-lastInsertion, element, parentPath);
+// regard elements as equal when they are not.
-// As we are only searching the original array we keep track of
-// those positions only
+// Use a separate index variable to search within the existing
-if (lastInsertion is items.length) {
+// elements that compare equally, see
-index = -1;
+// TreeViewerTestBug205700.testAddEquallySortedElements.
-} else {// See if we should just refresh
+int insertionIndexInItems = indexInItems;
-while (lastInsertion < items.length
+while( insertionIndexInItems < items.length
 && internalCompare(comparator, parentPath, element,
-items[lastInsertion].getData()) is 0) {
+items[insertionIndexInItems].getData()) is 0) {
 // As we cannot assume the sorter is consistent with
 // equals() - therefore we can
 // just check against the item prior to this index (if
 // any)
-if (items[lastInsertion].getData().opEquals(element)) {
+if (items[insertionIndexInItems].getData().opEquals(element)) {
-// refresh the element in case it has new children
+// Found the item for the element.
-internalRefresh(element);
+// Refresh the element in case it has new children.
-newItem = false;
+internalRefresh(element);
-}
+// Do not create a new item - continue with the next element.
-lastInsertion++;// We had an insertion so increment
+continue elementloop;
 }
-// Did we get to the end?
+insertionIndexInItems++;
-if (lastInsertion is items.length) {
+}
-index = -1;
+// Did we get to the end?
-} else {
+if (insertionIndexInItems is items.length) {
-index = lastInsertion + i; // Add the index as the
+createTreeItem(widget, element, -1);
-// array is growing
+newItems++;
-}
+} else {
-}
+// InsertionIndexInItems is the index in the original array. We
-}
+// need to correct by the number of new items we have
-if (newItem) {
+// created. See bug 205700.
-createTreeItem(widget, element, index);
+createTreeItem(widget, element, insertionIndexInItems + newItems);
+newItems++;
+}
 }
 }
 }
 /**
 *
 * @param widget
 *            the widget
 */
 protected void createChildren(Widget widget) {
-bool oldBusy = busy;
+bool oldBusy = isBusy();
-busy = true;
+setBusy(true);
 try {
 Item[] tis = getChildren(widget);
 if (tis !is null && tis.length > 0) {
 Object data = tis[0].getData();
 if (data !is null) {
 }
 }
 });
 } finally {
-busy = oldBusy;
+setBusy(oldBusy);
 }
 }
 /**
 * Creates a single item for the given parent and synchronizes it with the
 /* (non-Javadoc) Method declared on StructuredViewer. */
 protected override void doUpdateItem(Widget widget, Object element, bool fullMap) {
-bool oldBusy = busy;
+bool oldBusy = isBusy();
-busy = true;
+setBusy(true);
 try {
 if ( auto item = cast(Item)widget ) {
 // ensure that back pointer is correct
 if (fullMap) {
 // update icon and label
 SafeRunnable.run(new UpdateItemSafeRunnable(item, element));
 }
 } finally {
-busy = oldBusy;
+setBusy(oldBusy);
 }
 }
 /**
 * Expands all nodes of the viewer's tree, starting with the root. This
 * @param level
 *            non-negative level, or <code>ALL_LEVELS</code> to expand all
 *            levels of the tree
 */
 public void expandToLevel(Object elementOrTreePath, int level) {
-if (isBusy())
+if (checkBusy())
 return;
 Widget w = internalExpand(elementOrTreePath, true);
 if (w !is null) {
 internalExpandToLevel(w, level);
 }
 *            the tree expansion event
 * @see ITreeViewerListener#treeCollapsed
 */
 protected void fireTreeCollapsed(TreeExpansionEvent event) {
 Object[] listeners = treeListeners.getListeners();
-for (int i = 0; i < listeners.length; ++i) {
+bool oldBusy = isBusy();
-SafeRunnable.run(new class(event,cast(ITreeViewerListener) listeners[i]) SafeRunnable {
+setBusy(true);
-TreeExpansionEvent event_;
+try {
-ITreeViewerListener l;
+for (int i = 0; i < listeners.length; ++i) {
-this(TreeExpansionEvent a,ITreeViewerListener b){
+SafeRunnable.run(new class(event,cast(ITreeViewerListener) listeners[i]) SafeRunnable {
-event_=a;
+TreeExpansionEvent event_;
-l = b;
+ITreeViewerListener l;
-}
+this(TreeExpansionEvent a,ITreeViewerListener b){
-public void run() {
+event_=a;
-l.treeCollapsed(event_);
+l = b;
 }
-});
+public void run() {
+l.treeCollapsed(event_);
+}
+});
+}
+} finally {
+setBusy(oldBusy);
 }
 }
 /**
 * Fires a tree expanded event. Only listeners registered at the time this
 *            the tree expansion event
 * @see ITreeViewerListener#treeExpanded
 */
 protected void fireTreeExpanded(TreeExpansionEvent event) {
 Object[] listeners = treeListeners.getListeners();
-for (int i = 0; i < listeners.length; ++i) {
+bool oldBusy = isBusy();
-SafeRunnable.run(new class( event, cast(ITreeViewerListener) listeners[i]) SafeRunnable {
+setBusy(true);
-TreeExpansionEvent event_;
+try {
-ITreeViewerListener l;
+for (int i = 0; i < listeners.length; ++i) {
-this(TreeExpansionEvent a,ITreeViewerListener b){
+SafeRunnable.run(new class( event, cast(ITreeViewerListener) listeners[i]) SafeRunnable {
-event_=a;
+TreeExpansionEvent event_;
-l = b;
+ITreeViewerListener l;
-}
+this(TreeExpansionEvent a,ITreeViewerListener b){
-public void run() {
+event_=a;
-l.treeExpanded(event_);
+l = b;
 }
-});
+public void run() {
-}
+l.treeExpanded(event_);
+}
+});
+}
+} finally {
+setBusy(oldBusy);
+}
 }
 /**
 * Returns the auto-expand level.
 *
 return null;
 }
 /* (non-Javadoc) Method declared on StructuredViewer. */
 protected override Object[] getRawChildren(Object parentElementOrTreePath) {
-bool oldBusy = busy;
+bool oldBusy = isBusy();
-busy = true;
+setBusy(true);
 try {
 Object parent;
 TreePath path;
 if ( auto p = cast(TreePath)parentElementOrTreePath ) {
 path = p;
 }
 }
 }
 return null;
 } finally {
-busy = oldBusy;
+setBusy(oldBusy);
 }
 }
 /**
 * Returns all selected items for the given DWT control.
 */
 protected override void inputChanged(Object input, Object oldInput) {
 preservingSelection(new class Runnable {
 public void run() {
 Control tree = getControl();
-bool useRedraw = true;
+tree.setRedraw(false);
-// (size > REDRAW_THRESHOLD) || (table.getItemCount() >
+try {
-// REDRAW_THRESHOLD);
+removeAll(tree);
-if (useRedraw) {
+tree.setData(getRoot());
-tree.setRedraw(false);
+internalInitializeTree(tree);
-}
+} finally {
-removeAll(tree);
-tree.setData(getRoot());
-internalInitializeTree(tree);
-if (useRedraw) {
 tree.setRedraw(true);
 }
 }
 });
 }
 /**
 * Initializes the tree with root items, expanding to the appropriate
 IContentProvider cp = getContentProvider();
 if ( auto tpcp = cast(ITreePathContentProvider)cp ) {
 TreePath[] paths = tpcp.getParents(elementOrTreePath);
 if (paths.length > 0) {
 if (paths[0].getSegmentCount() is 0) {
-return getInput();
+return getRoot();
 }
 return paths[0].getLastSegment();
 }
 }
 if ( auto tcp = cast(ITreeContentProvider) cp ) {
 if (opEquals(element, input)) {
 setInput(null);
 return;
 }
 Widget[] childItems = internalFindItems(element);
-for (int j = 0; j < childItems.length; j++) {
+if (childItems.length > 0) {
-Widget childItem = childItems[j];
+for (int j = 0; j < childItems.length; j++) {
-if ( auto it = cast(Item)childItem ) {
+Widget childItem = childItems[j];
-disassociate(it);
+if ( auto it = cast(Item)childItem ) {
-childItem.dispose();
+disassociate(it);
+childItem.dispose();
+}
+}
+} else {
+// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=210747
+Object parent = getParentElement(element);
+if (parent !is null
+&& !equals(parent, getRoot())
+&& !(parent instanceof TreePath && ((TreePath) parent)
+.getSegmentCount() is 0)) {
+Widget[] parentItems = internalFindItems(parent);
+for (int j = 0; j < parentItems.length; j++) {
+Widget parentItem = parentItems[j];
+if (parentItem instanceof Item) {
+updatePlus((Item) parentItem, parent);
+}
+}
 }
 }
 }
 }
 // Find each place the parent appears in the tree
 Widget[] parentItemArray = findItems(parent);
 for (int i = 0; i < parentItemArray.length; i++) {
 Widget parentItem = parentItemArray[i];
+// May happen if parent element is a descendent of of a previously
+// removed element
+if (parentItem.isDisposed())
+continue;
 // Iterate over the child items and remove each one
 Item[] children = getChildren(parentItem);
-for (int j = 0; j < children.length; j++) {
+if (children.length is 1 && children[0].getData() is null &&
-Item child = children[j];
+parentItem instanceof Item) { // dummy node
+// Remove plus if parent element has no children
-Object data = child.getData();
+updatePlus((Item) parentItem, parent);
-if (data !is null && toRemove.containsKey(data)) {
+} else {
-disassociate(child);
+for (int j = 0; j < children.length; j++) {
-child.dispose();
+Item child = children[j];
+Object data = child.getData();
+if (data !is null && toRemove.containsKey(data)) {
+disassociate(child);
+child.dispose();
+}
 }
 }
 }
 }
 public void remove(Object[] elementsOrTreePaths) {
 assertElementsNotNull(elementsOrTreePaths);
 if (elementsOrTreePaths.length is 0) {
 return;
 }
-if (isBusy())
+if (checkBusy())
 return;
 preservingSelection(new class(elementsOrTreePaths) Runnable {
 Object[] elementsOrTreePaths_;
 this(Object[] a){
 elementsOrTreePaths_=a;
 public void remove(Object parent, Object[] elements) {
 assertElementsNotNull(elements);
 if (elements.length is 0) {
 return;
 }
-if (isBusy())
+if (checkBusy())
 return;
 preservingSelection(new class(parent,elements) Runnable {
 Object parent_;
 Object[] elements_;
 this(Object a,Object[] b){
 }
 return null;
 }
 /**
-* Sets the auto-expand level. The value 0 means that there is no
+* Sets the auto-expand level to be used when the input of the viewer is set
-* auto-expand; 1 means that top-level elements are expanded, but not their
+* using {@link #setInput(Object)}. The value 0 means that there is no
-* children; 2 means that top-level elements are expanded, and their
+* auto-expand; 1 means that the invisible root element is expanded (since
-* children, but not grandchildren; and so on.
+* most concrete subclasses do not show the root element, there is usually
+* no practical difference between using the values 0 and 1); 2 means that
+* top-level elements are expanded, but not their children; 3 means that
+* top-level elements are expanded, and their children, but not
+* grandchildren; and so on.
 * <p>
 * The value <code>ALL_LEVELS</code> means that all subtrees should be
 * expanded.
+* </p>
+* <p>
+* Note that in previous releases, the Javadoc for this method had an off-by
+* one error. See bug 177669 for details.
 * </p>
 *
 * @param level
 *            non-negative level, or <code>ALL_LEVELS</code> to expand all
 *            levels of the tree
 *            the array of expanded elements
 * @see #getExpandedElements
 */
 public void setExpandedElements(Object[] elements) {
 assertElementsNotNull(elements);
-if (isBusy()) {
+if (checkBusy()) {
 return;
 }
 CustomHashtable expandedElements = newHashtable(elements.length * 2 + 1);
 for (int i = 0; i < elements.length; ++i) {
 Object element = elements[i];
 *
 * @since 3.2
 */
 public void setExpandedTreePaths(TreePath[] treePaths) {
 assertElementsNotNull(treePaths);
-if (isBusy())
+if (checkBusy())
 return;
 IElementComparer treePathComparer = new class(getComparer()) IElementComparer {
 IElementComparer comparer;
 this(IElementComparer c){
 comparer = c;
 *            <code>true</code> if the node is expanded, and
 *            <code>false</code> if collapsed
 */
 public void setExpandedState(Object elementOrTreePath, bool expanded) {
 Assert.isNotNull(elementOrTreePath);
-if (isBusy())
+if (checkBusy())
 return;
 Widget item = internalExpand(elementOrTreePath, false);
 if ( cast(Item)item ) {
 if (expanded) {
 createChildren(item);
 }
 setSelection(newSelection);
 // Although setting the selection in the control should reveal it,
 // setSelection may be a no-op if the selection is unchanged,
-// so explicitly reveal the first item in the selection here.
+// so explicitly reveal items in the selection here.
 // See bug 100565 for more details.
 if (reveal && newSelection.size() > 0) {
-showItem(cast(Item) newSelection.get(0));
+// Iterate backwards so the first item in the list
+// is the one guaranteed to be visible
+for (int i = (newSelection.size()-1); i >= 0; i--) {
+showItem(cast(Item) newSelection.get(i));
+}
 }
 }
 /**
 * Shows the given item.
 int oldCnt = -1;
 if (widget is tree) {
 oldCnt = getItemCount(tree);
 }
-Item[] items = getChildren(widget);
+Item[] items = getChildren(widget,elementChildren);
 // save the expanded elements
 CustomHashtable expanded = newHashtable(CustomHashtable.DEFAULT_CAPACITY); // assume
 // num
 // expanded
 // is
 tree.setRedraw(true);
 }
 }
 /**
+* Return the items to be refreshed as part of an update. elementChildren are the
+* new elements.
+* @param widget
+* @param elementChildren
+* @since 3.4
+* @return Item[]
+* <strong>NOTE:</strong> This API is experimental and may be deleted
+* before 3.4 is released.
+*/
+public Item[] getChildren(Widget widget,  Object[] elementChildren) {
+return getChildren(widget);
+}
+/**
 * Updates the "+"/"-" icon of the tree node from the given element. It
 * calls <code>isExpandable</code> to determine whether an element is
 * expandable.
 *
 * @param item
 */
 public void insert(Object parentElementOrTreePath, Object element,
 int position) {
 Assert.isNotNull(parentElementOrTreePath);
 Assert.isNotNull(element);
-if (isBusy())
+if (checkBusy())
 return;
 if (getComparator() !is null || hasFilters()) {
 add(parentElementOrTreePath, [ element ]);
 return;
 }
 if (insertionPosition is -1) {
 insertionPosition = getItemCount(item);
 }
 createTreeItem(item, element, insertionPosition);
+} else {
+Object parentElement = parentElementOrTreePath;
+if (element instanceof TreePath)
+parentElement = ((TreePath) parentElement).getLastSegment();
+updatePlus(item, parentElement);
 }
 } else {
 int insertionPosition = position;
 if (insertionPosition is -1) {
 insertionPosition = getItemCount(cast(Control) widget);
 * @return <code>true</code> if the given object is either the input or an empty tree path,
 * <code>false</code> otherwise.
 * @since 3.3
 */
 final protected bool internalIsInputOrEmptyPath(Object elementOrTreePath) {
-if (elementOrTreePath.opEquals(getInput()))
+if (elementOrTreePath.opEquals(getRoot()))
 return true;
 if (!(cast(TreePath)elementOrTreePath ))
 return false;
 return (cast(TreePath) elementOrTreePath).getSegmentCount() is 0;
 }

Mercurial > projects > dwt-addons

comparison dwtx/jface/viewers/AbstractTreeViewer.d @ 70:46a6e0e6ccd4