Jface TreeViewer分类 - 更新

Question

从在jface treeviewer中进行排序行当我（如该页面上的问题）时，我的比较器不起作用，我只是想按标签提供商进行排序。

我的treeViewer在我的应用程序中使用的一些通用功能有些扩展。然后在3个派生范围内将其扩展，但是从本质上讲，它是抽象类的示例是因为它不是直接实例化的，并且Eclipse插件代码的其余部分必须为各种视图零件选择具体实现。但是，我需要在所有这些功能中分类功能，因此这可能是应该去的地方。

我匿名化了下面的代码，但本质上是treeViewer的抽象包装器，在所有派生中都有3列。第一列（索引0）始终是某种类型的树，因此节点是可扩展的，并且在第二列和第三列中产生更明显的数据行（索引1和2）。这些列仅包含文本数据。

因此，我希望实现的是一个可排序的控件，其中单击带有索引0的标头列将清除任何排序并在最初加载数据时渲染数据，而单击任何其他标头的单击都将执行以下操作：

1. 分类（UP）如果 则已经不是排序列
2. 如果重复单击相同的列，

转换方向，这是我尝试过的，从本文顶部的链接中提到的viewercomparator类开始：

    public abstract class MyTreeViewer extends TreeViewer {
    
        public static final int ACTIVE_TOTAL_COLUMN_WIDTH = 120;
        public static final int FIRST_COLUMN_WIDTH = 180;
    
        private static final String SPECIAL_FIELD = "specialField";
        private TreeColumn sortColumn = null;
    
        final RMService rmService;
        final PService pService;
    
        public MyTreeViewer(Composite parent) {
    
            this(parent, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION);
        }
    
        public MyTreeViewer(Composite parent, int style) {
    
            super(parent, style);
    
            this.rmService = UIActivator.getDefault().getInjector().getInstance(RMService.class);
            this.pService = UIActivator.getDefault().getInjector().getInstance(PService.class);
    
            this.setUseHashlookup(true);
    
            this.addSelectionChangedListener(new ISelectionChangedListener() {
    
                @Override
                public void selectionChanged(SelectionChangedEvent event) {
                    if (!event.getSelection().isEmpty()) {
                        Tree tree = getTree();
                        if (tree != null) {
                            List<MyTreeItem> treeItems = Lists.newArrayList();
                            for (int i = 0; i < tree.getSelectionCount(); i++) {
                                TreeItem item = tree.getSelection()[i];
                                Object obj = item.getData();
                                if (obj instanceof MyTreeItem) {
                                    treeItems.add((MyTreeItem) obj);
                                }
                            }
                            handleSelectionChanged(treeItems);
                        }
                    }
                }
            });
    
            this.setComparator(new ViewerComparator());
        }
    
        protected abstract void handleSelectionChanged(Collection<MyTreeItem> treeItemList);
    
        public void initTree(List<ViewField> fields, IMemento memento) {
    
            TableLayout tableLayout = new TableLayout();
            Tree tree = getTree();
    
            for (ViewField field : fields) {
    
                TreeViewerColumn column = new TreeViewerColumn(this, SWT.NONE);
                if (SystemPropertiesLoader.OPERATING_SYSTEM_NAME.equalsIgnoreCase(IConstants.LINUX_OS)) {
                    column.getColumn().setResizable(false);
                    column.getColumn().setMoveable(false);
                } else {
                    column.getColumn().setResizable(true);
                    column.getColumn().setMoveable(true);
                }
                column.getColumn().setData(SPECIAL_FIELD, field);
                column.getColumn().setText(field.getFieldName());
    
                tableLayout.addColumnData(new ColumnPixelData(field.getWidth(), false));
    
                column.getColumn().addSelectionListener(new SelectionListener() {
                    @Override
                    public void widgetSelected(SelectionEvent selectionEvent) {
                        if (selectionEvent.getSource() instanceof TreeColumn) {
                            TreeColumn column = (TreeColumn)selectionEvent.getSource();
                            Tree tree = getTree();
                            if (column.getText().equalsIgnoreCase("") && sortColumn != null) {
                                // file column clicked - use it to clear any sort order
                                sortColumn = null;
                                tree.setSortColumn(sortColumn);
                                tree.setSortDirection(0);
                                refresh();
                            } else {
                                sortColumn = column;
                                tree.setSortColumn(sortColumn);
                                tree.setSortDirection(invertSortDirection(tree.getSortDirection()));
                                refresh();
                            }
                        }
                    }
    
                    @Override
                    public void widgetDefaultSelected(SelectionEvent selectionEvent) {
                        // not currently used, but required as part of implementation of SelectionListener interface
                    }
                });
            }
            tree.setLayout(tableLayout);
            tree.setLinesVisible(false);
            tree.setHeaderVisible(true);
            tree.layout(true);
    
            // prevent expanding/collapsing tree item on dbl click
            tree.addListener(SWT.MeasureItem, new Listener() {
    
                @Override
                public void handleEvent(Event event) {
                    // nothing
                }
            });
        }
    
        private int invertSortDirection(int sortDirection) {
            if (sortDirection != SWT.UP && sortDirection != SWT.DOWN) {
                return SWT.UP;
            } else if (sortDirection == SWT.UP) {
                return SWT.DOWN;
            }
            return SWT.UP;
        }
    
        @Override
        public void refresh() {
            super.refresh();
        }
    
        @Override
        public void refresh(boolean updateLabels) {
            super.refresh(updateLabels);
        }
    }

我继承了此代码，所以有一些奇特的东西我不会在不知道它不会在质量检查中产生回归的固定错误，例如，可以实现防止在双击上扩展/折叠树项目的粗略方法。实际上，到目前为止，我修改的此特定代码的唯一部分是插入addSelectionListener用于处理列标头单击的闭合以及invertSortDirection方法。

当我运行此操作并单击标头时会发生什么。我看到UI Caret指示列索引1或2上的排序方向，但我看不到数据排序。单击列索引0的标题将清除排序列和顺序。如果分类数据，我希望观众在请求任何列排序之前将UI中的UI刷新为原始加载状态。

在先前的问题上（在顶部链接），我解释说，如果需要按标签进行排序，我应该只添加this.setComparator（new ViewerComparator（））; line。如果我必须编写扩展viewComparator的类，我不知道我会覆盖或更改。

上面代码中没有一个派生的类在列上实现侦听器。我可以跟踪代码，上述处理标头单击的代码确实执行。

因此，我是否需要扩展viewComparator，如果我这样做，我应该更改它以获得所需的行为？

（我也可能可以取消treecolumn stortcolumn字段，因为这棵树本身“记住”了

。 /strong>

我的目的是显示上面定义的这个通用查看器的派生类别，但是在我检查了这一点之后，很明显，对于当前的问题而言，很少有使用这种情况。

我发现了我认为的是为什么我从我继承了该项目的一个前任中没有出现这种类型的“吸烟枪”。这是标签提供商：

public class MyCustomLabelProvider extends LabelProvider implements ITableLabelProvider {

    final IDecoratorManager decorator;

    public MyCustomLabelProvider() {
        decorator = PlatformUI.getWorkbench().getDecoratorManager();
    }

    @Override
    public Image getImage(Object element) {
        return super.getImage(element);
    }

    @Override
    public String getText(Object element) {
        return null;
    }

    @Override
    public Image getColumnImage(Object element, int columnIndex) {
        if (element instanceof MyTreeItem) {
            if (columnIndex == 0) {
                final MyTreeItem item = (MyTreeItem)element;
                switch (item.getType()) {
                    // snipped cases returning different images
                }
            }
        }
        return null;
    }

    @Override
    public String getColumnText(Object element, int columnIndex) {
        if (element instanceof MyTreeItem) {
            return showColumns((MyTreeItem) element, columnIndex);
        }
        return null;
    }

    private String showColumns(MyTreeItem element, int columnIndex) {
        if (columnIndex == 0) {
            return element.getName();
        }
        if (columnIndex == 1) {
            return String.valueOf(element.getCustomProperty1());
        }
        if (columnIndex == 2) {
            return String.valueOf(element.getCustomProperty2());
        }
        return "";
    }
}

通过跟踪viewercomparator代码，该程序最终调用getText总是返回null。

viewercomparator仅尝试抓住标签文本，因此上述为null，它对空字符串进行了修改。然后，它使用Java String 进行比较方法。由于两者都是“”，因此没有比较结果可以交换元素顺序。

我想知道将getText方法更改为以某种方式获取单击列的原始列索引，并具有逻辑，以确定从我的基础数据对象中读取用于填充一行的基础数据对象。对我来说，这种转化为不起作用，因为我使用的基础对象具有用于填充3列中2个的非弦乐属性。

用户Greg-449在评论中指出，我需要扩展和覆盖viewercomparator制作自己的版本，但是直到我到达这么远，或者直到他说...

标准ViewerComparator仅支持一列

...目前尚不清楚为什么。最初链接的帖子没有澄清。或至少在撰写本文时。

在他提到的那一刻，我没有指出问题已解决，只是我以为我已经找到了这个问题。我只是从viewercomparator，跟踪运行代码开始，并找到了现有比较器无法重新排序项目的原因，假设一旦我更新代码，那可能是它的终结。

我会进一步访问Greg-449所说的话，因为即使您有一列，默认viewercomparator 也不会支持比较基础数据对象的属性不是一个元素的元素Java字符串。您需要为此实施自己的比较器。因此很清楚，为什么Greg -449建议在我一开始说我有3列 - 但是我仍然感到困惑，因为我只是以为我在我想可以分类的2列上有文本数据，即使该文本实际上是转换了从int。我只是以为我阅读的链接帖子可能很合适，因为它提到了对文本进行排序，而没有提及单列或Java字符串数据类型的限制。

因此，继续前进，我现在已经按照自己的意愿来工作。更重要的是，我不必更改getText方法，因为这是由默认的view> viewercomparator专门调用的，我找到了一种不需要的方法。我将在答案中发布这些。

Answer 1

因此，除了我在问题中的更新之外……

我试图找到GREG-449引用的其他比较器的示例，但是如果我尝试导入它，则在我的环境中不可用。

然后，我搜索了编写自定义比较器并找到Vogella帖子的方法：
https://www.vogella.com/教程/eclipsejfacetable/acrate.html＃-sort-content-of-collumns

我注意到上面提到的列索引问题是通过在Vogella代码中的每个列中创建处理程序来处理的。我主要是复制它的，对其执行比较的方式有所更改以满足我的要求：

public class MyCustomViewerComparator extends ViewerComparator {
    private int propertyIndex;
    private static final int DESCENDING = 1;
    private int direction;

    public MyCustomViewerComparator() {
        this.propertyIndex = 0;
        direction = DESCENDING;
    }

    public int getDirection() {
        return direction == 1 ? SWT.DOWN : SWT.UP;
    }

    public void setColumn(int column) {
        if (column == this.propertyIndex) {
            // Same column as last sort; toggle the direction
            direction = 1 - direction;
        } else {
            // New column; do an ascending sort
            this.propertyIndex = column;
            direction = DESCENDING;
        }
    }

    @Override
    public int compare(Viewer viewer, Object e1, Object e2) {
        MyTreeItem p1 = (MyTreeItem) e1;
        MyTreeItem p2 = (MyTreeItem) e2;
        int rc = 0;
        switch (propertyIndex) {
            case 1:
                rc = p1.getCustomProperty1() - p2.getCustomProperty1();
                break;
            case 2:
                rc = p1.getCustomProperty2() - p2.getCustomProperty2();
                break;
            default:
                rc = 0;
        }
        // If descending order, flip the direction
        if (direction == DESCENDING) {
            rc = -rc;
        }
        return rc;
    }
}

可以看出，我们有一个标准比较函数，该函数返回负数，匹配时为零或正面数字，指示哪个命令应在。或按照标准Javadoc所述：

值{@code 0}如果参数字符串等于
*这个字符串;值小于{@code 0}的值
*在词典上比字符串论点小；和
*值大于{@code 0}如果此字符串为
*在词典上大于字符串参数。

就在我的版本中，比较是从我的数据对象中使用int值。

除此之外，如果用户单击了违约列的列标题为列索引0，我希望它清除任何形式并返回到最初加载的格式。

为此，我只是更改了我最初在myTreeViewer中使用的selectionListener（请参阅有问题的第二个代码列表）每列使用以下vogella示例（再次调整）：

    private SelectionAdapter getSelectionAdapter(final TreeColumn column,
                                                 final int index) {
        SelectionAdapter selectionAdapter = new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                comparator.setColumn(index);
                if (index == 0) {
                    viewer.getTree().setSortDirection(0);
                    viewer.getTree().setSortColumn(null);
                } else {
                    int dir = comparator.getDirection();
                    viewer.getTree().setSortDirection(dir);
                    viewer.getTree().setSortColumn(column);
                }
                viewer.refresh();
            }
        };
        return selectionAdapter;
    }

if（index == 0）在上面的检查中检查时，请在我的其他列标头上清除我的排序点击。由于列索引与如何设置列有关，因此不会在UI中具有可移动列的影响。您可以在没有有害效果的情况下更改可见的列排序。

从我学到的知识中，这只是比较工具性元素并且需要在自定义比较器中覆盖的元素的逻辑。除此之外，唯一要识别的是，您希望通过实现selectapter接口并将其添加到列中，同时也能够跟踪列索引，从而希望将比较器专门连接到每一列。 Vogella链接确实显示了这一点。基本上，您会在比较器上看到setColumn方法，并且在selectionAdapter中使用此列来设置要在比较>中测试的列索引< /代码>。