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 |