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

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

下面是完整的

ViewPart

代码

树可以很好地交互工作，也就是说，我可以打开所有级别，最多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();
    }

}

package try\u 13\u expandtreeview；
导入org.eclipse.jface.action.action；
导入org.eclipse.jface.viewers.IElementComparer；
导入org.eclipse.jface.viewers.ITreeContentProvider；
导入org.eclipse.jface.viewers.LabelProvider；
导入org.eclipse.jface.viewers.TreePath；
导入org.eclipse.jface.viewers.TreeViewer；
导入org.eclipse.jface.viewers.Viewer；
导入org.eclipse.swt.swt；
导入org.eclipse.swt.widgets.Composite；
导入org.eclipse.ui.ISharedImages；
导入org.eclipse.ui.PlatformUI；
导入org.eclipse.ui.part.ViewPart；
公共类视图扩展了ViewPart{
public static final String ID=“Try\u 13\u ExpandTreeView.view”；
私人TreeViewer查看器；
私人行动1；
/**
*每个模型元素都是一个“三元组”，即新对象[3]
* 
*空间坐标轴的第一个元素是父元素
* 
*第二个数字是一个级别，从叶子到根编号
* 
*第三个数字是元素的数值（内容）
* 
*@author-dims
*
*/
类ViewContentProvider实现ITreeContentProvider{
公共无效输入已更改（查看器v、对象oldInput、对象newInput）{
}
公共空间处置（）{
}
公共对象[]getElements（对象父对象）{
返回getChildren（父级）；
}
@凌驾
公共对象[]获取子对象（对象父对象）{
对象[]空间坐标轴=（对象[]）父对象；
如果（（（int）三元组[1]）>0）{
Object[]children=新对象[10]；
对象[]儿童；
对于（int i=0；i 0；
}
}
类ViewLabelProvider扩展了LabelProvider{
@凌驾
公共字符串getText（对象元素）{
Object[]空间坐标轴=（Object[]）元素；
返回（（整数）空间坐标轴[2]）.toString（）；
}
}
类ViewElementComparer实现IElementComparer{
@凌驾
公共布尔等于（对象a、对象b）{
对象[]空间坐标轴a=（对象[]）a；
对象[]空间坐标轴b=（对象[]）b；
返回（（int）空间坐标轴a[2]）==（（int）空间坐标轴b[2]）；
}
@凌驾
公共int哈希代码（对象元素）{
Object[]空间坐标轴=（Object[]）元素；
返回（（int）三元组[2]）；
}
}
/**
*这是一个回调，允许我们创建查看器并进行初始化
*它。
*/
公共void createPartControl（复合父级）{
查看器=新的TreeViewer（父级，SWT.MULTI | SWT.H_滚动
|SWT.V_卷轴）；
setContentProvider（新的ViewContentProvider（））；
setLabelProvider（新的ViewLabelProvider（））；
setComparer（新的ViewElementComparer（））；
setInput（新对象[]{null，10，0}）；
action1=新操作（）{
公开募捐{
树路径[]树路径={
新树路径（新对象[]{
新对象[]{null，0，2}，
新对象[]{null，0，7}，
新对象[]{null，0，4}
})
};
//viewer.setexpandedtreepath（树路径）；//不起作用
查看器.expandToLevel（树路径[0]，树视图.ALL_级别）；
//setExpandedElements（新对象[]{viewer.getTree（）.getItems（）[3].getData（）}）；
}
};
行动1.setText（“行动1”）；
动作1.setToolTipText（“动作1工具提示”）；
操作1.setImageDescriptor（PlatformUI.getWorkbench（）.getSharedImages（）。
getImageDescriptor（ISharedImages.IMG_OBJS_INFO_TSK））；
getViewSite（）.getActionBars（）.getToolBarManager（）.add（action1）；
}
/**
*将焦点请求传递给查看器的控件。
*/
public void setFocus（）{
viewer.getControl（）.setFocus（）；
}
}

这些调用的

TreePath

参数只是对象模型中的一个对象数组（由内容提供商提供）。该数组从树中的顶级对象开始（内容提供商

getElements

调用返回的一个对象）。数组中的第二个条目是顶级元素的子元素，依此类推，每个子元素都要展开

您显示的

getTreePathFromItem

代码从它要展开的树的“叶”开始，并通过项父级向上返回到树的顶部。由于树路径需要从上到下，因此它生成的列表是反向的

调用

TreeViewer.setUseHashlookup（true）

有助于树查看器查找这些对象

更新：

internalGetWidgetToSelect

操作，使用

TreePath

输入，检查空路径后，调用：

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

从注释中可以看出，同一个模型对象可能有多个树项-我不确定何时使用，但我认为这并不常见。如果确实有多个树项，则

TreePath

不明确，因此代码依次查看每个项的父树路径以查找匹配项

---

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

只需在查看器上执行expandAll，然后检查GetExpandedTreepath的结果即可

如果你有下面的树

N1
  N1B
    N1C
N2
N3
..

…如果你想让N1C可见，你必须

tp1 = new TreePath({N1});
tp2 = new TreePath({N1, N1B});
tp3 = new TreePath({N1, N1B, N1C});
// viewer.expandAll()
viewer.setExpandedTreePaths({tp1, tp2, tp3});