java - 如何在 SWT/Tree 和/或 JFace/TreeViewer 中扩展给定路径？

Question

我写了一个非常大的惰性树模型，无法通过给定路径以编程方式扩展它

下面是完整的 ViewPart 代码。

Tree 交互工作良好，即我可以打开所有级别，最多 10 个。但我不能以编程方式执行此操作。

我编写了自定义 ViewElementComparer 来比较元素。

package try_13_expandtreeview;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.viewers.IElementComparer;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;

public class View extends ViewPart {

    public static final String ID = "Try_13_ExpandTreeView.view";

    private TreeViewer viewer;

    private Action action1;

    /**
     * Each model element is a "triad", i.e. new Object[3]
     * 
     * First element of a triad is a parent element
     * 
     * Second number is a level, numbered from leafs to root
     * 
     * Third number is numeric value (content) of an element
     * 
     * @author dims
     *
     */
    class ViewContentProvider implements ITreeContentProvider {
        public void inputChanged(Viewer v, Object oldInput, Object newInput) {
        }

        public void dispose() {
        }

        public Object[] getElements(Object parent) {
            return getChildren(parent);
        }

        @Override
        public Object[] getChildren(Object parent) {
            Object[] triade = (Object[]) parent;
            if( ((int)triade[1]) > 0 ) {
                Object[] children = new Object[10];
                Object[] child;
                for(int i=0; i<10; ++i) {
                    child = new Object[3];
                    child[0] = parent;
                    child[1] = ((int)triade[1])-1;
                    child[2] = i;
                    children[i] = child;
                }
                return children;
            }
            else {
                return new Object[0];
            }
        }

        @Override
        public Object getParent(Object element) {
            Object[] triade = (Object[]) element;
            return triade[0];
        }

        @Override
        public boolean hasChildren(Object element) {
            Object[] triade = (Object[]) element;
            return ((int)triade[1]) > 0;
        }
    }

    class ViewLabelProvider extends LabelProvider {
        @Override
        public String getText(Object element) {
            Object[] triade = (Object[]) element;
            return ((Integer)triade[2]).toString();
        }
    }

    class ViewElementComparer implements IElementComparer {

        @Override
        public boolean equals(Object a, Object b) {
            Object[] triade_a = (Object[]) a;
            Object[] triade_b = (Object[]) b;
            return ((int)triade_a[2]) == ((int)triade_b[2]); 
        }

        @Override
        public int hashCode(Object element) {
            Object[] triade = (Object[]) element;
            return ((int)triade[2]);
        }

    }

    /**
     * This is a callback that will allow us to create the viewer and initialize
     * it.
     */
    public void createPartControl(Composite parent) {
        viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL
                | SWT.V_SCROLL);

        viewer.setContentProvider(new ViewContentProvider());
        viewer.setLabelProvider(new ViewLabelProvider());
        viewer.setComparer(new ViewElementComparer());

        viewer.setInput(new Object[] {null, 10, 0});

        action1 = new Action() {
            public void run() {


                TreePath[] treePaths = {
                        new TreePath(new Object[] {
                                new Object[] {null, 0, 2},
                                new Object[] {null, 0, 7},
                                new Object[] {null, 0, 4}
                        })
                };

                // viewer.setExpandedTreePaths(treePaths); // does not work 
                viewer.expandToLevel(treePaths[0], TreeViewer.ALL_LEVELS);





                //viewer.setExpandedElements(new Object[] { viewer.getTree().getItems()[3].getData()});
            }
        };
        action1.setText("Action 1");
        action1.setToolTipText("Action 1 tooltip");
        action1.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().
            getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK));

        getViewSite().getActionBars().getToolBarManager().add(action1);
    }

    /**
     * Passing the focus request to the viewer's control.
     */
    public void setFocus() {
        viewer.getControl().setFocus();
    }

}

Answer 1

这些调用的 TreePath 参数只是来自对象模型的一组对象(由您的内容提供商提供)。该数组从树中的顶级对象开始(内容提供程序 getElements 调用返回的对象之一)。数组中的第二个条目是顶级元素的子元素，以此类推您要扩展的每个子元素。

您显示的 getTreePathFromItem 代码从它要扩展的树的“叶子”开始，并通过项目父项向上返回到树的顶部。由于树路径需要从上到下，因此它构建的列表是相反的。

调用 TreeViewer.setUseHashlookup(true) 有助于树查看器查找这些对象。

更新:使用 TreePath 输入的 internalGetWidgetToSelect 操作，在检查空路径后我们调用:

Widget[] candidates = findItems(treePath.getLastSegment());

从评论中可以看出，同一个模型对象可以有多个树项——我不确定何时使用它，但我认为这不常见。如果您确实有多个树项目，则 TreePath 是不明确的，因此代码会依次查看每个项目的父树路径以找到匹配项。

因此，在模型对象只有一个叶项的正常情况下，这可能比从树路径的根开始并找到每个子项更快，因为与模型对象匹配的树项的搜索较少。