KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > jdt > internal > ui > typehierarchy > SelectionProviderMediator


1 /*******************************************************************************
2  * Copyright (c) 2000, 2005 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Eclipse Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/epl-v10.html
7  *
8  * Contributors:
9  * IBM Corporation - initial API and implementation
10  *******************************************************************************/

11 package org.eclipse.jdt.internal.ui.typehierarchy;
12
13 import org.eclipse.swt.events.FocusEvent;
14 import org.eclipse.swt.events.FocusListener;
15 import org.eclipse.swt.widgets.Control;
16 import org.eclipse.swt.widgets.Widget;
17
18 import org.eclipse.jface.util.Assert;
19 import org.eclipse.jface.util.ListenerList;
20 import org.eclipse.jface.viewers.IPostSelectionProvider;
21 import org.eclipse.jface.viewers.ISelection;
22 import org.eclipse.jface.viewers.ISelectionChangedListener;
23 import org.eclipse.jface.viewers.ISelectionProvider;
24 import org.eclipse.jface.viewers.SelectionChangedEvent;
25 import org.eclipse.jface.viewers.StructuredSelection;
26 import org.eclipse.jface.viewers.StructuredViewer;
27
28 /**
29  * A selection provider for viewparts with more that one viewer.
30  * Tracks the focus of the viewers to provide the correct selection.
31  */

32 public class SelectionProviderMediator implements IPostSelectionProvider {
33
34     private class InternalListener implements ISelectionChangedListener, FocusListener {
35         /*
36          * @see ISelectionChangedListener#selectionChanged
37          */

38         public void selectionChanged(SelectionChangedEvent event) {
39             doSelectionChanged(event);
40         }
41         
42         /*
43          * @see FocusListener#focusGained
44          */

45         public void focusGained(FocusEvent e) {
46             doFocusChanged(e.widget);
47         }
48     
49         /*
50          * @see FocusListener#focusLost
51          */

52         public void focusLost(FocusEvent e) {
53             // do not reset due to focus behaviour on GTK
54
//fViewerInFocus= null;
55
}
56     }
57     
58     private class InternalPostSelectionListener implements ISelectionChangedListener {
59         public void selectionChanged(SelectionChangedEvent event) {
60             doPostSelectionChanged(event);
61         }
62         
63     }
64     
65     private StructuredViewer[] fViewers;
66
67     private StructuredViewer fViewerInFocus;
68     private ListenerList fSelectionChangedListeners;
69     private ListenerList fPostSelectionChangedListeners;
70     
71     /**
72      * @param viewers All viewers that can provide a selection
73      * @param viewerInFocus the viewer currently in focus or <code>null</code>
74      */

75     public SelectionProviderMediator(StructuredViewer[] viewers, TypeHierarchyViewer viewerInFocus) {
76         Assert.isNotNull(viewers);
77         fViewers= viewers;
78         InternalListener listener= new InternalListener();
79         fSelectionChangedListeners= new ListenerList(4);
80         fPostSelectionChangedListeners= new ListenerList(4);
81         fViewerInFocus= viewerInFocus;
82
83         for (int i= 0; i < fViewers.length; i++) {
84             StructuredViewer viewer= fViewers[i];
85             viewer.addSelectionChangedListener(listener);
86             viewer.addPostSelectionChangedListener(new InternalPostSelectionListener());
87             Control control= viewer.getControl();
88             control.addFocusListener(listener);
89         }
90     }
91     
92     private void doFocusChanged(Widget control) {
93         for (int i= 0; i < fViewers.length; i++) {
94             if (fViewers[i].getControl() == control) {
95                 propagateFocusChanged(fViewers[i]);
96                 return;
97             }
98         }
99     }
100     
101     final void doPostSelectionChanged(SelectionChangedEvent event) {
102         ISelectionProvider provider= event.getSelectionProvider();
103         if (provider == fViewerInFocus) {
104             firePostSelectionChanged();
105         }
106     }
107     
108     final void doSelectionChanged(SelectionChangedEvent event) {
109         ISelectionProvider provider= event.getSelectionProvider();
110         if (provider == fViewerInFocus) {
111             fireSelectionChanged();
112         }
113     }
114     
115     final void propagateFocusChanged(StructuredViewer viewer) {
116         if (viewer != fViewerInFocus) { // Ok to compare by idendity
117
fViewerInFocus= viewer;
118             fireSelectionChanged();
119             firePostSelectionChanged();
120         }
121     }
122     
123     private void fireSelectionChanged() {
124         if (fSelectionChangedListeners != null) {
125             SelectionChangedEvent event= new SelectionChangedEvent(this, getSelection());
126             
127             Object JavaDoc[] listeners= fSelectionChangedListeners.getListeners();
128             for (int i= 0; i < listeners.length; i++) {
129                 ISelectionChangedListener listener= (ISelectionChangedListener) listeners[i];
130                 listener.selectionChanged(event);
131             }
132         }
133     }
134     
135     private void firePostSelectionChanged() {
136         if (fPostSelectionChangedListeners != null) {
137             SelectionChangedEvent event= new SelectionChangedEvent(this, getSelection());
138             
139             Object JavaDoc[] listeners= fPostSelectionChangedListeners.getListeners();
140             for (int i= 0; i < listeners.length; i++) {
141                 ISelectionChangedListener listener= (ISelectionChangedListener) listeners[i];
142                 listener.selectionChanged(event);
143             }
144         }
145     }
146     
147     /*
148      * @see ISelectionProvider#addSelectionChangedListener
149      */

150     public void addSelectionChangedListener(ISelectionChangedListener listener) {
151         fSelectionChangedListeners.add(listener);
152     }
153     
154     /*
155      * @see ISelectionProvider#removeSelectionChangedListener
156      */

157     public void removeSelectionChangedListener(ISelectionChangedListener listener) {
158         fSelectionChangedListeners.remove(listener);
159     }
160     
161     /* (non-Javadoc)
162      * @see org.eclipse.jface.viewers.IPostSelectionProvider#addPostSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener)
163      */

164     public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
165         fPostSelectionChangedListeners.add(listener);
166     }
167
168
169     /* (non-Javadoc)
170      * @see org.eclipse.jface.viewers.IPostSelectionProvider#removePostSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener)
171      */

172     public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
173         fPostSelectionChangedListeners.remove(listener);
174     }
175         
176     /*
177      * @see ISelectionProvider#getSelection
178      */

179     public ISelection getSelection() {
180         if (fViewerInFocus != null) {
181             return fViewerInFocus.getSelection();
182         }
183         return StructuredSelection.EMPTY;
184     }
185     
186     /*
187      * @see ISelectionProvider#setSelection
188      */

189     public void setSelection(ISelection selection) {
190         if (fViewerInFocus != null) {
191             fViewerInFocus.setSelection(selection);
192         }
193     }
194
195     /**
196      * Returns the viewer in focus or null if no viewer has the focus
197      */

198     public StructuredViewer getViewerInFocus() {
199         return fViewerInFocus;
200     }
201 }
202
Popular Tags