Eclipse plugin 如何在一个视图中设置两个选择提供程序

我有一个视图，其中有两个树查看器。在

createPartControl（）

中，如何为两个视图设置

selectionProviders

。这需要他们中的任何一个

这是我的片段。 查看代码：

IWorkbenchWindow workbenchWindow=PlatformUI.getWorkbench（）.getActiveWorkbenchWindow（）；
IWorkbenchPartSite activePartSite=workbenchWindow.getActivePage（）.getActivePart（）.getSite（）；
activePartSite.setSelectionProvider（InputReViewer）；
activePartSite.setSelectionProvider（compositeTreeViewer）；
//这里的最后一行是顶部的选择提供程序代码。
//因此，我只能从第二棵树中进行选择。

我们怎样才能解决这个问题？我尝试从

ISelectionProvider

继承视图类，并重写

getSelection（）

方法。但这没有任何帮助

---

有人可以提出建议吗？

我建议在每个树中添加一个焦点侦听器，并使用当前焦点树查看器调用

partSite.setSelectionProvider（）

。例如：

treeViewer1.getTree（）.addListener（SWT.FocusIn，event->site.setSelectionProvider（treeViewer1））；
treeViewer2.getTree（）.addListener（SWT.FocusIn，event->site.setSelectionProvider（treeViewer2））；

我将把它作为一个练习留给读者，以消除侦听器重复

或者，您可以创建一个代理选择提供程序，用于侦听树查看器中的选择更改并传播最近的选择。大致如下：

公共类ProxySelectionProvider实现ISelectionProvider{
私人选择；
私人最终收集听众；
公共ProxySelectionProvider（StructuredViewer…查看器）{
侦听器=新的ArrayList（）；
selection=StructuredSelection.EMPTY；
for（StructuredViewer:查看器）{
ISelectionChangedListener selectionListener=此：：selectionChanged；
viewer.addSelectionChangedListener（selectionListener）；
viewer.getControl（）.addDisposeListener（事件->查看器.removeSelectionChangedListener（selectionListener））；
}
}
@凌驾
public void addSelectionChangedListener（ISelectionChangedListener侦听器）{
添加（侦听器）；
}
@凌驾
public void removeSelectionChangedListener（ISelectionChangedListener侦听器）{
删除（侦听器）；
}
@凌驾
公共ISelection getSelection（）{
返回选择；
}
@凌驾
公共选举（ISelection selection）{
this.selection=选择；
}
私有无效selectionChanged（SelectionChangedEvent事件）{
selection=event.getSelection（）；
notifyListeners（）；
}
私有void notifyListeners（）{
SelectionChangedEvent=新建SelectionChangedEvent（此，选择）；
新建ArrayList（侦听器）.forEach（侦听器->侦听器.selectionChanged（事件））；
}
}

像这样使用选择提供程序：

ISelectionProvider selectionProvider = new ProxySelectionProvider( treeViewer1, treeViewer2 );
IWorkbenchPartSite partSite = workbenchWindow.getActivePage().getActivePart().getSite();
partSite.setSelectionProvider( selectionProvider );

---

我建议为每个树添加一个焦点侦听器，并使用当前焦点树查看器调用

partSite.setSelectionProvider（）

。例如：

treeViewer1.getTree（）.addListener（SWT.FocusIn，event->site.setSelectionProvider（treeViewer1））；
treeViewer2.getTree（）.addListener（SWT.FocusIn，event->site.setSelectionProvider（treeViewer2））；

我将把它作为一个练习留给读者，以消除侦听器重复

或者，您可以创建一个代理选择提供程序，用于侦听树查看器中的选择更改并传播最近的选择。大致如下：

公共类ProxySelectionProvider实现ISelectionProvider{
私人选择；
私人最终收集听众；
公共ProxySelectionProvider（StructuredViewer…查看器）{
侦听器=新的ArrayList（）；
selection=StructuredSelection.EMPTY；
for（StructuredViewer:查看器）{
ISelectionChangedListener selectionListener=此：：selectionChanged；
viewer.addSelectionChangedListener（selectionListener）；
viewer.getControl（）.addDisposeListener（事件->查看器.removeSelectionChangedListener（selectionListener））；
}
}
@凌驾
public void addSelectionChangedListener（ISelectionChangedListener侦听器）{
添加（侦听器）；
}
@凌驾
public void removeSelectionChangedListener（ISelectionChangedListener侦听器）{
删除（侦听器）；
}
@凌驾
公共ISelection getSelection（）{
返回选择；
}
@凌驾
公共选举（ISelection selection）{
this.selection=选择；
}
私有无效selectionChanged（SelectionChangedEvent事件）{
selection=event.getSelection（）；
notifyListeners（）；
}
私有void notifyListeners（）{
SelectionChangedEvent=新建SelectionChangedEvent（此，选择）；
新建ArrayList（侦听器）.forEach（侦听器->侦听器.selectionChanged（事件））；
}
}

像这样使用选择提供程序：

ISelectionProvider selectionProvider = new ProxySelectionProvider( treeViewer1, treeViewer2 );
IWorkbenchPartSite partSite = workbenchWindow.getActivePage().getActivePart().getSite();
partSite.setSelectionProvider( selectionProvider );

---

我用这种方法解决了这个问题

public class SelectionProviderAdapater implements IPostSelectionProvider {
    public class InternalListener implements ISelectionChangedListener, FocusListener {
        @Override
        public void focusGained(FocusEvent e) {
            doFocusChanged(e.widget);
        }

        @Override
        public void focusLost(FocusEvent e) {
        }

        @Override
        public void selectionChanged(SelectionChangedEvent event) {
            doSelectionChanged(event);
        }
    }

    /**
     * The array of viewers.
     */
    private StructuredViewer[] viewers;

    /**
     * The current viewer in focus.
     */
    private StructuredViewer viewerInFocus;

    /**
     * The list of selection changed listeners.
     */
    private final ListenerList selectionChangedListeners = new ListenerList();

    /**
     * The list of post selection changed listeners.
     */
    private final ListenerList postSelectionChangedListeners = new ListenerList();

    /**
     * The internal listener instance.
     */
    private final InternalListener internalListener = new InternalListener();

    /**
     * The internal post selection listener instance.
     */
    private final ISelectionChangedListener internalPostSelectionListener = new ISelectionChangedListener() {
        @Override
        public void selectionChanged(SelectionChangedEvent event) {
            doPostSelectionChanged(event);
        }
    };

    @Override
    public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
        postSelectionChangedListeners.add(listener);
    }

    @Override
    public void addSelectionChangedListener(ISelectionChangedListener listener) {
        selectionChangedListeners.add(listener);
    }

    /**
     * Sets the viewer in focus and fires selection change events.
     *
     * @param control
     *            The {@link Widget} that has gained focus.
     */
    private void doFocusChanged(Widget control) {
        for (StructuredViewer viewer : viewers) {
            if (viewer.getControl() == control) {
                propagateFocusChanged(viewer);
                return;
            }
        }
    }

    /**
     * Fires post selection changed events if the {@link SelectionChangedEvent}
     * 's selection provider is the current viewer in focus.
     *
     * @param event
     *            The selection changed event.
     */
    private void doPostSelectionChanged(SelectionChangedEvent event) {
        ISelectionProvider provider = event.getSelectionProvider();
        if (provider == viewerInFocus) {
            firePostSelectionChanged();
        }
    }

    /**
     * Fires selection changed events if the {@link SelectionChangedEvent}'s
     * selection provider is the current viewer in focus.
     *
     * @param event
     *            The selection changed event.
     */
    private void doSelectionChanged(SelectionChangedEvent event) {
        ISelectionProvider provider = event.getSelectionProvider();
        if (provider == viewerInFocus) {
            fireSelectionChanged();
        }
    }

    /**
     * Notifies post selection changed listeners of a selection changed event.
     */
    private void firePostSelectionChanged() {
        if (postSelectionChangedListeners != null) {
            SelectionChangedEvent event = new SelectionChangedEvent(this, getSelection());

            Object[] listeners = postSelectionChangedListeners.getListeners();
            for (Object listener : listeners) {
                ISelectionChangedListener selectionChangedListener = (ISelectionChangedListener) listener;
                selectionChangedListener.selectionChanged(event);
            }
        }
    }

    /**
     * Notifies selection changed listeners of a selection changed event.
     */
    private void fireSelectionChanged() {
        if (selectionChangedListeners != null) {
            SelectionChangedEvent event = new SelectionChangedEvent(this, getSelection());

            Object[] listeners = selectionChangedListeners.getListeners();
            for (Object listener : listeners) {
                ISelectionChangedListener selectionChangedListener = (ISelectionChangedListener) listener;
                selectionChangedListener.selectionChanged(event);
            }
        }
    }

    @Override
    public ISelection getSelection() {
        if (viewerInFocus != null) {
            return viewerInFocus.getSelection();
        }
        return StructuredSelection.EMPTY;
    }

    public StructuredViewer getViewerInFocus() {
        return viewerInFocus;
    }

    /**
     * Sets the viewer as the viewer in focus and fires selection changed
     * events.
     *
     * @param viewer
     *            The new viewer in focus.
     */
    private void propagateFocusChanged(StructuredViewer viewer) {
        if (viewer != viewerInFocus) {
            viewerInFocus = viewer;
            fireSelectionChanged();
            firePostSelectionChanged();
        }
    }

    @Override
    public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
        postSelectionChangedListeners.remove(listener);
    }

    @Override
    public void removeSelectionChangedListener(ISelectionChangedListener listener) {
        selectionChangedListeners.remove(listener);
    }

    @Override
    public void setSelection(ISelection selection) {
        if (viewerInFocus != null) {
            viewerInFocus.setSelection(selection);
        }
    }

    /**
     * Sets the selection on the current viewer in focus.
     *
     * @param selection
     *            The selection to set.
     * @param reveal
     *            true if the selection is to be made visible, and false
     *            otherwise
     */
    public void setSelection(ISelection selection, boolean reveal) {
        if (viewerInFocus != null) {
            viewerInFocus.setSelection(selection, reveal);
        }
    }

    /**
     * Sets the collection of viewers to be monitored by this mediator.
     *
     * @param newViewers
     *            The collection of viewers.
     */
    public void setViewers(Collection<? extends StructuredViewer> newViewers) {
        // Remove listeners from any previous viewers.
        if (viewers != null) {
            for (StructuredViewer viewer : viewers) {
                viewer.removeSelectionChangedListener(internalListener);
                viewer.removePostSelectionChangedListener(internalPostSelectionListener);
                Control control = viewer.getControl();
                if (!control.isDisposed()) {
                    control.removeFocusListener(internalListener);
                }
            }
        }
        viewers = null;
        viewerInFocus = null;

        if (newViewers != null) {
            viewers = newViewers.toArray(new StructuredViewer[newViewers.size()]);
            for (StructuredViewer viewer : viewers) {
                viewer.addSelectionChangedListener(internalListener);
                viewer.addPostSelectionChangedListener(internalPostSelectionListener);
                Control control = viewer.getControl();
                control.addFocusListener(internalListener);
                if (control.isFocusControl()) {
                    propagateFocusChanged(viewer);
                }
            }
        }
    }
}

公共类SelectionProviderAdapter实现IPostSelectionProvider{
公共类InternalListener实现ISelectionChangedListener，FocusListener{
@凌驾
获得公共无效焦点（焦点事件e）{
doFocusChanged（如widget）；
}
@凌驾
公共无效焦点丢失（焦点事件e）{
}
@凌驾
公共作废selectionChanged（SelectionChangedEvent事件）{
剂量选择改变（事件）；
}
}
/**
*观众群。
*/
私有结构查看者[]查看者；
/**
*当前查看器处于焦点。
*/
私有结构查看者焦点；
/**
*选择列表更改了侦听器。
*/
私人最终监听器列表选择更改监听器=新监听器li