|
1
11 package org.eclipse.jdt.internal.ui.workingsets;
12
13 import java.util.ArrayList  ;
14 import java.util.Arrays ;
15 import java.util.Iterator ;
16 import java.util.List ;
17
18 import org.eclipse.core.runtime.Assert;
19
20 import org.eclipse.swt.widgets.Shell;
21
22 import org.eclipse.jface.action.ActionContributionItem;
23 import org.eclipse.jface.action.IAction;
24 import org.eclipse.jface.action.IContributionItem;
25 import org.eclipse.jface.action.IMenuListener;
26 import org.eclipse.jface.action.IMenuManager;
27 import org.eclipse.jface.action.IToolBarManager;
28 import org.eclipse.jface.action.Separator;
29 import org.eclipse.jface.util.IPropertyChangeListener;
30 import org.eclipse.jface.util.PropertyChangeEvent;
31 import org.eclipse.jface.viewers.ViewerFilter;
32
33 import org.eclipse.ui.IActionBars;
34 import org.eclipse.ui.IMemento;
35 import org.eclipse.ui.IWorkbenchPage;
36 import org.eclipse.ui.IWorkbenchPartSite;
37 import org.eclipse.ui.IWorkbenchPreferenceConstants;
38 import org.eclipse.ui.IWorkingSet;
39 import org.eclipse.ui.IWorkingSetManager;
40 import org.eclipse.ui.PlatformUI;
41 import org.eclipse.ui.actions.ActionGroup;
42
43 import org.eclipse.jdt.internal.ui.search.WorkingSetComparator;
44
45
51 public class WorkingSetFilterActionGroup extends ActionGroup implements IWorkingSetActionGroup {
52
53 private static final String TAG_WORKING_SET_NAME= "workingSetName"; private static final String TAG_IS_WINDOW_WORKING_SET= "isWindowWorkingSet"; private static final String LRU_GROUP= "workingSet_lru_group";
57 private final WorkingSetFilter fWorkingSetFilter;
58
59 private IWorkingSet fWorkingSet= null;
60
61 private final ClearWorkingSetAction fClearWorkingSetAction;
62 private final SelectWorkingSetAction fSelectWorkingSetAction;
63 private final EditWorkingSetAction fEditWorkingSetAction;
64
65 private IPropertyChangeListener fWorkingSetListener;
66 private IPropertyChangeListener fChangeListener;
67
68 private int fLRUMenuCount;
69 private IMenuManager fMenuManager;
70 private IMenuListener fMenuListener;
71 private List fContributions= new ArrayList ();
72 private final IWorkbenchPage fWorkbenchPage;
73 private boolean fAllowWindowWorkingSetByDefault;
74
75 public WorkingSetFilterActionGroup(IWorkbenchPartSite site, IPropertyChangeListener changeListener) {
76 Assert.isNotNull(site);
77 Assert.isNotNull(changeListener);
78
79 fChangeListener= changeListener;
80 fWorkbenchPage= site.getPage();
81 fAllowWindowWorkingSetByDefault= true;
82 fClearWorkingSetAction= new ClearWorkingSetAction(this);
83 fSelectWorkingSetAction= new SelectWorkingSetAction(this, site);
84 fEditWorkingSetAction= new EditWorkingSetAction(this, site);
85
86 fWorkingSetListener= new IPropertyChangeListener() {
87 public void propertyChange(PropertyChangeEvent event) {
88 doPropertyChange(event);
89 }
90 };
91 fWorkingSetFilter= new WorkingSetFilter();
92
93 IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
94 manager.addPropertyChangeListener(fWorkingSetListener);
95
96 if (useWindowWorkingSetByDefault()) {
97 setWorkingSet(site.getPage().getAggregateWorkingSet(), false);
98 }
99 }
100
101 public WorkingSetFilterActionGroup(Shell shell, IWorkbenchPage page, IPropertyChangeListener changeListener) {
102 Assert.isNotNull(shell);
103 Assert.isNotNull(changeListener);
104
105 fWorkbenchPage= page;
106 fAllowWindowWorkingSetByDefault= false;
107 fChangeListener= changeListener;
108 fClearWorkingSetAction= new ClearWorkingSetAction(this);
109 fSelectWorkingSetAction= new SelectWorkingSetAction(this, shell);
110 fEditWorkingSetAction= new EditWorkingSetAction(this, shell);
111
112 fWorkingSetListener= new IPropertyChangeListener() {
113 public void propertyChange(PropertyChangeEvent event) {
114 doPropertyChange(event);
115 }
116 };
117
118 fWorkingSetFilter= new WorkingSetFilter();
119
120 IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
121 manager.addPropertyChangeListener(fWorkingSetListener);
122
123 setWorkingSet(null, false);
124 }
125
126
133 public boolean isFiltered(Object parent, Object object) {
134 if (fWorkingSetFilter == null)
135 return false;
136 return !fWorkingSetFilter.select(null, parent, object);
137 }
138
139
140
145 public IWorkingSet getWorkingSet() {
146 return fWorkingSet;
147 }
148
149
155 public void setWorkingSet(IWorkingSet workingSet, boolean refreshViewer) {
156 fClearWorkingSetAction.setEnabled(workingSet != null);
158 fEditWorkingSetAction.setEnabled(workingSet != null && !workingSet.isAggregateWorkingSet());
159
160 fWorkingSet= workingSet;
161
162 fWorkingSetFilter.setWorkingSet(workingSet);
163 if (refreshViewer) {
164 fChangeListener.propertyChange(new PropertyChangeEvent(this, IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE, null, workingSet));
165 }
166 }
167
168
173 public void saveState(IMemento memento) {
174 String workingSetName= ""; boolean isWindowWorkingSet= false;
176 if (fWorkingSet != null) {
177 if (fWorkingSet.isAggregateWorkingSet()) {
178 isWindowWorkingSet= true;
179 } else {
180 workingSetName= fWorkingSet.getName();
181 }
182 }
183 memento.putString(TAG_IS_WINDOW_WORKING_SET, Boolean.toString(isWindowWorkingSet));
184 memento.putString(TAG_WORKING_SET_NAME, workingSetName);
185 }
186
187
194 public void restoreState(IMemento memento) {
195 boolean isWindowWorkingSet;
196 if (memento.getString(TAG_IS_WINDOW_WORKING_SET) != null) {
197 isWindowWorkingSet= Boolean.valueOf(memento.getString(TAG_IS_WINDOW_WORKING_SET)).booleanValue();
198 } else {
199 isWindowWorkingSet= useWindowWorkingSetByDefault();
200 }
201 String workingSetName= memento.getString(TAG_WORKING_SET_NAME);
202 boolean hasWorkingSetName= workingSetName != null && workingSetName.length() > 0;
203
204 IWorkingSet ws= null;
205 if (hasWorkingSetName) {
207 ws= PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSet(workingSetName);
208 } else if (isWindowWorkingSet && fWorkbenchPage != null) {
209 ws= fWorkbenchPage.getAggregateWorkingSet();
210 }
211 setWorkingSet(ws, false);
212 }
213
214 private boolean useWindowWorkingSetByDefault() {
215 return fAllowWindowWorkingSetByDefault && PlatformUI.getPreferenceStore().getBoolean(IWorkbenchPreferenceConstants.USE_WINDOW_WORKING_SET_BY_DEFAULT);
216 }
217
218
219
222 public void fillActionBars(IActionBars actionBars) {
223 fillToolBar(actionBars.getToolBarManager());
224 fillViewMenu(actionBars.getMenuManager());
225 }
226
227
232 private void fillToolBar(IToolBarManager tbm) {
233 }
235
236
241 public void fillViewMenu(IMenuManager mm) {
242 if (mm.find(IWorkingSetActionGroup.ACTION_GROUP) == null) {
243 mm.add(new Separator(IWorkingSetActionGroup.ACTION_GROUP));
244 }
245 add(mm, fSelectWorkingSetAction);
246 add(mm, fClearWorkingSetAction);
247 add(mm, fEditWorkingSetAction);
248 add(mm, new Separator());
249 add(mm, new Separator(LRU_GROUP));
250
251 fMenuManager= mm;
252 fMenuListener= new IMenuListener() {
253 public void menuAboutToShow(IMenuManager manager) {
254 removePreviousLRUWorkingSetActions(manager);
255 addLRUWorkingSetActions(manager);
256 }
257 };
258 fMenuManager.addMenuListener(fMenuListener);
259 }
260
261 private void add(IMenuManager mm, IAction action) {
262 IContributionItem item= new ActionContributionItem(action);
263 mm.appendToGroup(ACTION_GROUP, item);
264 fContributions.add(item);
265 }
266
267 private void add(IMenuManager mm, IContributionItem item) {
268 mm.appendToGroup(ACTION_GROUP, item);
269 fContributions.add(item);
270 }
271
272 private void removePreviousLRUWorkingSetActions(IMenuManager mm) {
273 for (int i= 1; i < fLRUMenuCount; i++) {
274 String id= WorkingSetMenuContributionItem.getId(i);
275 IContributionItem item= mm.remove(id);
276 if (item != null) {
277 item.dispose();
278 fContributions.remove(item);
279 }
280 }
281 }
282
283 private void addLRUWorkingSetActions(IMenuManager mm) {
284 IWorkingSet[] workingSets= PlatformUI.getWorkbench().getWorkingSetManager().getRecentWorkingSets();
285 Arrays.sort(workingSets, new WorkingSetComparator());
286
287 int currId= 1;
288 if (fWorkbenchPage != null) {
289 addLRUWorkingSetAction(mm, currId++, fWorkbenchPage.getAggregateWorkingSet());
290 }
291
292 for (int i= 0; i < workingSets.length; i++) {
293 if (!workingSets[i].isAggregateWorkingSet()) {
294 addLRUWorkingSetAction(mm, currId++, workingSets[i]);
295 }
296 }
297 fLRUMenuCount= currId;
298 }
299
300 private void addLRUWorkingSetAction(IMenuManager mm, int id, IWorkingSet workingSet) {
301 IContributionItem item= new WorkingSetMenuContributionItem(id, this, workingSet);
302 mm.insertBefore(LRU_GROUP, item);
303 fContributions.add(item);
304 }
305
306
307 public void cleanViewMenu(IMenuManager menuManager) {
308 for (Iterator iter= fContributions.iterator(); iter.hasNext();) {
309 IContributionItem removed= menuManager.remove((IContributionItem) iter.next());
310 if (removed != null) {
311 removed.dispose();
312 }
313 }
314 fContributions.clear();
315 fMenuManager.removeMenuListener(fMenuListener);
316 fMenuListener= null;
317 }
318
319
322 public void dispose() {
323 if (fMenuManager != null && fMenuListener != null)
324 fMenuManager.removeMenuListener(fMenuListener);
325
326 if (fWorkingSetListener != null) {
327 PlatformUI.getWorkbench().getWorkingSetManager().removePropertyChangeListener(fWorkingSetListener);
328 fWorkingSetListener= null;
329 }
330 fChangeListener= null;
332 super.dispose();
333 }
334
335
338 public ViewerFilter getWorkingSetFilter() {
339 return fWorkingSetFilter;
340 }
341
342
345 private void doPropertyChange(PropertyChangeEvent event) {
346 String property= event.getProperty();
347 if (IWorkingSetManager.CHANGE_WORKING_SET_NAME_CHANGE.equals(property)) {
348 fChangeListener.propertyChange(event);
349 } else if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(property)) {
350 IWorkingSet newWorkingSet= (IWorkingSet) event.getNewValue();
351 if (newWorkingSet.equals(fWorkingSet)) {
352 if (fWorkingSetFilter != null) {
353 fWorkingSetFilter.notifyWorkingSetContentChange(); }
355 fChangeListener.propertyChange(event);
356 }
357 }
358 }
359 }
360 |
Popular Tags |
Java API By Example, From Geeks To Geeks.