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

Question

我有一个视图，其中有两个树视图。在createPartControl()中，我如何为这两个视图设置selectionProviders。它需要其中一个。

这是我的代码片段。 视图代码：

IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow(); 
IWorkbenchPartSite activePartSite = workbenchWindow.getActivePage().getActivePart().getSite(); 
activePartSite.setSelectionProvider(inputTreeViewer); 
activePartSite.setSelectionProvider(compositeTreeViewer); 

// Here the last line the selection provider code for the top one. 
// Hence I only get selections from the second tree. 

怎样才能解决这个问题呢？我尝试继承ISelectionProvider的视图类并覆盖getSelection()方法。但这没有任何帮助。

有人可以提出一些建议吗？

Answer 1

我建议为每棵树添加一个焦点侦听器，并用当前集中的树查看器调用partSite.setSelectionProvider()。例如：

treeViewer1.getTree().addListener(SWT.FocusIn, event -> site.setSelectionProvider(treeViewer1)); 
treeViewer2.getTree().addListener(SWT.FocusIn, event -> site.setSelectionProvider(treeViewer2)); 

我将把它留作练习，以便读者移除侦听器重复。

或者，您可以创建代理选择提供程序，该选择提供程序在两个树查看器中侦听选择更改并传播最近的选择。沿着这些路线的东西：

public class ProxySelectionProvider implements ISelectionProvider { 

    private ISelection selection; 
    private final Collection<ISelectionChangedListener> listeners; 

    public ProxySelectionProvider(StructuredViewer... viewers) { 
    listeners = new ArrayList<>(); 
    selection = StructuredSelection.EMPTY; 
    for(StructuredViewer viewer : viewers) { 
     ISelectionChangedListener selectionListener = this::selectionChanged; 
     viewer.addSelectionChangedListener(selectionListener); 
     viewer.getControl().addDisposeListener(event -> viewer.removeSelectionChangedListener(selectionListener)); 
    } 
    } 

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

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

    @Override 
    public ISelection getSelection() { 
    return selection; 
    } 

    @Override 
    public void setSelection(ISelection selection) { 
    this.selection = selection; 
    } 

    private void selectionChanged(SelectionChangedEvent event) { 
    selection = event.getSelection(); 
    notifyListeners(); 
    } 

    private void notifyListeners() { 
    SelectionChangedEvent event = new SelectionChangedEvent(this, selection); 
    new ArrayList<>(listeners).forEach(listener -> listener.selectionChanged(event)); 
    } 
} 

使用选择供应商是这样的：

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

Answer 2

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

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); 
       } 
      } 
     } 
    } 
} 

在view.Set观众使用setViewers（）用于selection.Then它设置为选择provider.It应该开始工作，我们要聆听需要哪些方法创建这个类的一个实例。