在给定的路径之后，TreeViewer.setSelection()不会选择正确的项

If there are more tree items based on the same object in the tree viewer, making a TreePath and passing it to TreeViewer.setSelection() does not select the item correctly when the current selection is equal to the one I want to navigate.

如果树查看器中有更多基于相同对象的树项，那么创建一个TreePath并将其传递给treeview . setselection()，当当前选择与我希望导航的对象相等时，不会正确地选择该项。

Example:
There's a tree with 2 items that show the same object (BigDecimal.ONE in this case). They have different paths (different parents):

示例:有一个树，其中有两个条目显示相同的对象(BigDecimal)。在这种情况下)。他们有不同的道路(不同的父母):

I want that when I am on one BigDecimal.ONE item, to click on the link and navigate to the other BigDecimal.ONE. On the selection listener of the link I make a TreeSelection with a correct TreePath. Then I call setSelection. But the navigation does not work. However, if the root item is initially collapsed, I notice that it expands it, but does not navigate to the correct item.

当我在一个大十进制数时。一个条目，点击链接并导航到另一个bigdecimal。在链接的选择侦听器上，我使用正确的TreePath进行树的选择。然后我叫setSelection。但是导航不能工作。但是，如果根项最初是折叠的，我注意到它展开了它，但是没有导航到正确的项。

The code is this:

的代码是这样的:

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.jface.viewers.*;
import org.eclipse.jface.window.ApplicationWindow;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.*;

public class TreeViewerExample {

    static class Model {
        String   name;
        Number[] children;

        public Model(String name, Number... numbers) {
            this.name = name;
            this.children = numbers;
        }

        public String toString() {
            return name;
        }
    }

    static class ModelTreeProvider extends LabelProvider implements ITableLabelProvider, ITreeContentProvider {

        public Object[] getChildren(Object parentElement) {
            if (parentElement instanceof Model) {
                return ((Model) parentElement).children;
            } else {
                return new Object[0];
            }
        }
        public Object getParent(Object element) {
            System.err.println("requesting the parent for " + element);
            return null;
        }
        public boolean hasChildren(Object element)
        {
            return getChildren(element) == null ? false : getChildren(element).length > 0;
        }
        public Object[] getElements(Object inputElement)
        {
            return (inputElement instanceof List)? ((List) inputElement).toArray():new Object[0];
        }
        public void dispose()
        {
        }
        public void inputChanged(Viewer arg0, Object arg1, Object arg2)
        {
        }
        public String getColumnText(Object element, int columnIndex)
        {
            return element.toString();
        }
        public Image getColumnImage(Object element, int columnIndex)
        {
            return null;
        }
    }

    public static void main(String[] args) {
        final List<Model> models = new ArrayList<Model>();
        models.add(new Model("Zero and one", BigDecimal.ZERO, BigDecimal.ONE));
        models.add(new Model("One and ten", BigDecimal.ONE, BigDecimal.TEN));

        Window app = new ApplicationWindow(null) {
            private TreeViewer treeViewer;
            private Link       link;
            protected Control createContents(Composite parent) {
                Composite composite = new Composite(parent, SWT.NONE);
                composite.setLayout(new FillLayout());
                treeViewer = new TreeViewer(composite);
                ModelTreeProvider provider = new ModelTreeProvider();
                treeViewer.setContentProvider(provider);
                treeViewer.setLabelProvider(provider);
                treeViewer.setInput(models);
                treeViewer.getTree().addSelectionListener(new SelectionAdapter() {
                    @Override
                    public void widgetSelected(SelectionEvent e) {
                        if (((TreeItem) e.item).getText().equals("1")) {
                            link.setText("This is from "+((TreeItem) e.item).getParentItem().getText()
                                    + "\r\n<a href=\"go\">Go to the other " + ((TreeItem) e.item).getText() + "</a>");
                        } else {
                            link.setText(" - ");
                        }
                        link.setData(e.item);
                    }
                });
                link = new Link(composite, SWT.NONE);
                link.setText(" - ");
                link.addSelectionListener(new SelectionAdapter() {
                    public void widgetSelected(SelectionEvent e) {
                        List<Object> path = new ArrayList<Object>();
                        if (treeViewer.getTree().indexOf(treeViewer.getTree().getSelection()[0].getParentItem()) == 0)
                        {// if the first is selected, go to the second
                            path.add(treeViewer.getTree().getItem(1).getData());
                        } else {
                            path.add(treeViewer.getTree().getItem(0).getData());
                        }
                        path.add(BigDecimal.ONE);
                        treeViewer.setSelection(new TreeSelection(new TreePath(path.toArray())), true);
                    }
                });
                return composite;
            }
        };
        app.setBlockOnOpen(true);
        app.open();
    }
}

My question is if this a jface bug or am I not doing this the right way?

我的问题是，如果这是一个jface错误，还是我做得不对?

---

EDIT:

编辑:

It looks that there is already a posted bug on eclipse.org: https://bugs.eclipse.org/bugs/show_bug.cgi?id=332736

它看起来已经在eclipse.org上发布了一个bug: https://bugs.eclipse.org/bugs/show_bug.cgi?id=332736。

1 个解决方案

#1

It looks like this is a bug in JFace. After all, you are passing TreePath so it should figure it out which exactly instance of your object you want.

看起来这是JFace中的一个bug。毕竟，您正在传递TreePath，因此它应该确定您想要的对象的具体实例。

The problem is the org.eclipse.jface.viewers.AbstractTreeViewer.isSameSelection(List, Item[]) method. It incorrectly determine, based on the element found in the items (the BigIntegers) that the selection is the same. It should have checked the whole tree path to make sure that the selection will be indeed the same. Fortunately, you can fix this in your code by overriding the isSameSelection(List, Item[]) method and correctly check against the tree paths instead of the elements themselves:

问题是org. eclipsee .jface. viewers.abstracttreeviewer。isSameSelection(列表,项目[])方法。根据在项目(BigIntegers)中找到的元素，它错误地确定了选择是相同的。它应该检查整个树路径，以确保所选内容确实相同。幸运的是，您可以通过重写isSameSelection(List, Item[])方法在代码中修复这个问题，并正确地检查树路径而不是元素本身:

       treeViewer = new TreeViewer(composite) {
            protected boolean isSameSelection(List items, Item[] current) {
                // If they are not the same size then they are not equivalent
                int n = items.size();
                if (n != current.length) {
                    return false;
                }
                Set itemSet = new HashSet(n * 2 + 1);
                for (Iterator i = items.iterator(); i.hasNext();) {
                    Item item = (Item) i.next();
                    itemSet.add(getTreePathFromItem(item));
                }
                // Go through the items of the current collection
                // If there is a mismatch return false
                for (int i = 0; i < current.length; i++) {
                    if (current[i].getData() == null
                            || !itemSet.contains(getTreePathFromItem(current[i]))) {
                        return false;
                    }
                }
                return true;
            }
       };

This however will fix this particular problem, but there is no guarantee that there are other problems waiting to be found. Personally, I always try to stay away of having the same elements in different places of the tree, just in case.

然而，这将解决这个特殊的问题，但不能保证还有其他问题等着被发现。就我个人而言，我总是尽量避免在树的不同地方使用相同的元素，以防万一。