/*******************************************************************************
* Copyright (c) 2000, 2011 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.internal.ui.workingsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.IElementComparer;
import org.eclipse.ui.ILocalWorkingSetManager;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.IWorkingSetUpdater;
import org.eclipse.ui.PlatformUI;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
public class WorkingSetModel {
public static final String CHANGE_WORKING_SET_MODEL_CONTENT= "workingSetModelChanged"; //$NON-NLS-1$
public static final IElementComparer COMPARER= new WorkingSetComparar();
private static final String TAG_LOCAL_WORKING_SET_MANAGER= "localWorkingSetManager"; //$NON-NLS-1$
/**
* Key associated with the state of all working sets.
* @since 3.7
*/
private static final String TAG_ALL_WORKING_SETS= "allWorkingSets"; //$NON-NLS-1$
private static final String TAG_ACTIVE_WORKING_SET= "activeWorkingSet"; //$NON-NLS-1$
private static final String TAG_WORKING_SET_NAME= "workingSetName"; //$NON-NLS-1$
private static final String TAG_CONFIGURED= "configured"; //$NON-NLS-1$
/**
* Key associated with the sort state of working sets.
*
* @since 3.5
*/
private static final String TAG_SORT_WORKING_SETS= "sortWorkingSets"; //$NON-NLS-1$
private final ILocalWorkingSetManager fLocalWorkingSetManager;
private List<IWorkingSet> fActiveWorkingSets;
private ListenerList fListeners;
private IPropertyChangeListener fWorkingSetManagerListener;
private OthersWorkingSetUpdater fOthersWorkingSetUpdater;
private final ElementMapper fElementMapper= new ElementMapper();
private boolean fConfigured;
/**
* Value of the sorted state of working sets.
*
* @since 3.5
*/
private boolean fIsSortingEnabled;
/**
* List of all working sets.
* @since 3.7
*/
private List<IWorkingSet> fAllWorkingSets;
private static class WorkingSetComparar implements IElementComparer {
public boolean equals(Object o1, Object o2) {
IWorkingSet w1= o1 instanceof IWorkingSet ? (IWorkingSet)o1 : null;
IWorkingSet w2= o2 instanceof IWorkingSet ? (IWorkingSet)o2 : null;
if (w1 == null || w2 == null)
return o1.equals(o2);
return w1 == w2;
}
public int hashCode(Object element) {
if (element instanceof IWorkingSet)
return System.identityHashCode(element);
return element.hashCode();
}
}
private static class ElementMapper {
private final Map<IAdaptable, Object> fElementToWorkingSet= new HashMap<IAdaptable, Object>();
private final Map<IWorkingSet, IAdaptable[]> fWorkingSetToElement= new IdentityHashMap<IWorkingSet, IAdaptable[]>();
private final Map<IAdaptable, Object> fResourceToWorkingSet= new HashMap<IAdaptable, Object>();
private final List<IAdaptable> fNonProjectTopLevelElements= new ArrayList<IAdaptable>();
public void clear() {
fElementToWorkingSet.clear();
fWorkingSetToElement.clear();
fResourceToWorkingSet.clear();
fNonProjectTopLevelElements.clear();
}
public void rebuild(IWorkingSet[] workingSets) {
clear();
for (int i= 0; i < workingSets.length; i++) {
put(workingSets[i]);
}
}
public IAdaptable[] refresh(IWorkingSet ws) {
IAdaptable[] oldElements= fWorkingSetToElement.get(ws);
if (oldElements == null)
return null;
IAdaptable[] newElements= ws.getElements();
List<IAdaptable> toRemove= new ArrayList<IAdaptable>(Arrays.asList(oldElements));
List<IAdaptable> toAdd= new ArrayList<IAdaptable>(Arrays.asList(newElements));
computeDelta(toRemove, toAdd, oldElements, newElements);
for (Iterator<IAdaptable> iter= toAdd.iterator(); iter.hasNext();) {
addElement(iter.next(), ws);
}
for (Iterator<IAdaptable> iter= toRemove.iterator(); iter.hasNext();) {
removeElement(iter.next(), ws);
}
if (toRemove.size() > 0 || toAdd.size() > 0)
fWorkingSetToElement.put(ws, newElements);
return oldElements;
}
private void computeDelta(List<IAdaptable> toRemove, List<IAdaptable> toAdd, IAdaptable[] oldElements, IAdaptable[] newElements) {
for (int i= 0; i < oldElements.length; i++) {
toAdd.remove(oldElements[i]);
}
for (int i= 0; i < newElements.length; i++) {
toRemove.remove(newElements[i]);
}
}
public IWorkingSet getFirstWorkingSet(Object element) {
return (IWorkingSet)getFirstElement(fElementToWorkingSet, element);
}
public List<IWorkingSet> getAllWorkingSets(Object element) {
List<IWorkingSet> allElements= getAllElements(fElementToWorkingSet, element);
if (allElements.isEmpty() && element instanceof IJavaElement) {
// try a second time in case the working set was manually updated (bug 168032)
allElements= getAllElements(fElementToWorkingSet, ((IJavaElement) element).getResource());
}
return allElements;
}
public List<IWorkingSet> getAllWorkingSetsForResource(IResource resource) {
return getAllElements(fResourceToWorkingSet, resource);
}
public List<IAdaptable> getNonProjectTopLevelElements() {
return fNonProjectTopLevelElements;
}
private void put(IWorkingSet ws) {
if (fWorkingSetToElement.containsKey(ws))
return;
IAdaptable[] elements= ws.getElements();
fWorkingSetToElement.put(ws, elements);
for (int i= 0; i < elements.length; i++) {
IAdaptable element= elements[i];
addElement(element, ws);
if (!(element instanceof IProject) && !(element instanceof IJavaProject)) {
fNonProjectTopLevelElements.add(element);
}
}
}
private void addElement(IAdaptable element, IWorkingSet ws) {
addToMap(fElementToWorkingSet, element, ws);
IResource resource= (IResource)element.getAdapter(IResource.class);
if (resource != null) {
addToMap(fResourceToWorkingSet, resource, ws);
}
}
private void removeElement(IAdaptable element, IWorkingSet ws) {
removeFromMap(fElementToWorkingSet, element, ws);
IResource resource= (IResource)element.getAdapter(IResource.class);
if (resource != null) {
removeFromMap(fResourceToWorkingSet, resource, ws);
}
}
private void addToMap(Map<IAdaptable, Object> map, IAdaptable key, IWorkingSet value) {
Object obj= map.get(key);
if (obj == null) {
map.put(key, value);
} else if (obj instanceof IWorkingSet) {
List<IWorkingSet> l= new ArrayList<IWorkingSet>(2);
l.add((IWorkingSet) obj);
l.add(value);
map.put(key, l);
} else if (obj instanceof List) {
@SuppressWarnings("unchecked")
List<IWorkingSet> sets= (List<IWorkingSet>)obj;
sets.add(value);
}
}
private void removeFromMap(Map<IAdaptable, Object> map, IAdaptable key, IWorkingSet value) {
Object current= map.get(key);
if (current == null) {
return;
} else if (current instanceof List) {
@SuppressWarnings("unchecked")
List<IWorkingSet> sets= (List<IWorkingSet>)current;
sets.remove(value);
switch (sets.size()) {
case 0:
map.remove(key);
break;
case 1:
map.put(key, sets.get(0));
break;
}
} else if (current == value) {
map.remove(key);
}
}
private Object getFirstElement(Map<IAdaptable, Object> map, Object key) {
Object obj= map.get(key);
if (obj instanceof List) {
@SuppressWarnings("unchecked")
List<IWorkingSet> sets= (List<IWorkingSet>)obj;
return sets.get(0);
}
return obj;
}
private List<IWorkingSet> getAllElements(Map<IAdaptable, Object> map, Object key) {
Object obj= map.get(key);
if (obj instanceof List) {
@SuppressWarnings("unchecked")
List<IWorkingSet> sets= (List<IWorkingSet>)obj;
return sets;
}
if (obj == null)
return Collections.emptyList();
List<IWorkingSet> result= new ArrayList<IWorkingSet>(1);
result.add((IWorkingSet) obj);
return result;
}
}
/**
* @param memento a memento, or <code>null</code>
*/
public WorkingSetModel(IMemento memento) {
fLocalWorkingSetManager= PlatformUI.getWorkbench().createLocalWorkingSetManager();
addListenersToWorkingSetManagers();
fActiveWorkingSets= new ArrayList<IWorkingSet>();
fAllWorkingSets= new ArrayList<IWorkingSet>();
if (memento == null || ! restoreState(memento)) {
IWorkingSet others= fLocalWorkingSetManager.createWorkingSet(WorkingSetMessages.WorkingSetModel_others_name, new IAdaptable[0]);
others.setId(IWorkingSetIDs.OTHERS);
fLocalWorkingSetManager.addWorkingSet(others);
fActiveWorkingSets.add(others);
fAllWorkingSets.add(others);
}
Assert.isNotNull(fOthersWorkingSetUpdater);
fElementMapper.rebuild(getActiveWorkingSets());
fOthersWorkingSetUpdater.updateElements();
}
private void addListenersToWorkingSetManagers() {
fListeners= new ListenerList(ListenerList.IDENTITY);
fWorkingSetManagerListener= new IPropertyChangeListener() {
public void propertyChange(PropertyChangeEvent event) {
workingSetManagerChanged(event);
}
};
PlatformUI.getWorkbench().getWorkingSetManager().addPropertyChangeListener(fWorkingSetManagerListener);
fLocalWorkingSetManager.addPropertyChangeListener(fWorkingSetManagerListener);
}
public void dispose() {
if (fWorkingSetManagerListener != null) {
PlatformUI.getWorkbench().getWorkingSetManager().removePropertyChangeListener(fWorkingSetManagerListener);
fLocalWorkingSetManager.removePropertyChangeListener(fWorkingSetManagerListener);
fLocalWorkingSetManager.dispose();
fWorkingSetManagerListener= null;
}
}
//---- model relationships ---------------------------------------
public IAdaptable[] getChildren(IWorkingSet workingSet) {
return workingSet.getElements();
}
public Object getParent(Object element) {
if (element instanceof IWorkingSet && fActiveWorkingSets.contains(element))
return this;
return fElementMapper.getFirstWorkingSet(element);
}
public Object[] getAllParents(Object element) {
if (element instanceof IWorkingSet && fActiveWorkingSets.contains(element))
return new Object[] {this};
return fElementMapper.getAllWorkingSets(element).toArray();
}
public Object[] addWorkingSets(Object[] elements) {
List<? super IWorkingSet> result= null;
for (int i= 0; i < elements.length; i++) {
Object element= elements[i];
List<IWorkingSet> sets= null;
if (element instanceof IResource) {
sets= fElementMapper.getAllWorkingSetsForResource((IResource)element);
} else {
sets= fElementMapper.getAllWorkingSets(element);
}
if (sets != null && sets.size() > 0) {
if (result == null)
result= new ArrayList<Object>(Arrays.asList(elements));
result.addAll(sets);
}
}
if (result == null)
return elements;
return result.toArray();
}
public boolean needsConfiguration() {
return !fConfigured && fActiveWorkingSets.size() == 1 &&
IWorkingSetIDs.OTHERS.equals(fActiveWorkingSets.get(0).getId());
}
public void configured() {
fConfigured= true;
}
//---- working set management -----------------------------------
/**
* Adds a property change listener.
*
* @param listener the property change listener to add
*/
public void addPropertyChangeListener(IPropertyChangeListener listener) {
fListeners.add(listener);
}
/**
* Removes the property change listener.
*
* @param listener the property change listener to remove
*/
public void removePropertyChangeListener(IPropertyChangeListener listener) {
fListeners.remove(listener);
}
public IWorkingSet[] getActiveWorkingSets() {
return fActiveWorkingSets.toArray(new IWorkingSet[fActiveWorkingSets.size()]);
}
/**
* Returns the array of all working sets.
*
* @return the array of all working sets
* @since 3.7
*/
public IWorkingSet[] getAllWorkingSets() {
if (fAllWorkingSets.size() == 1 && IWorkingSetIDs.OTHERS.equals(fAllWorkingSets.get(0).getId()))
fAllWorkingSets= getActiveAndAllWorkingSetsFromManagers();
return fAllWorkingSets.toArray(new IWorkingSet[fAllWorkingSets.size()]);
}
/**
* Returns the list containing active and all working sets from the working set managers.
*
* @return the list of all the working sets
* @since 3.7
*/
private List<IWorkingSet> getActiveAndAllWorkingSetsFromManagers() {
List<IWorkingSet> result= new ArrayList<IWorkingSet>();
result.addAll(fActiveWorkingSets);
IWorkingSet[] locals= fLocalWorkingSetManager.getWorkingSets();
for (int i= 0; i < locals.length; i++) {
if (!result.contains(locals[i]) && isSupportedAsTopLevelElement(locals[i]))
result.add(locals[i]);
}
IWorkingSet[] globals= PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSets();
for (int i= 0; i < globals.length; i++) {
if (!result.contains(globals[i]) && isSupportedAsTopLevelElement(globals[i]))
result.add(globals[i]);
}
if (fIsSortingEnabled)
Collections.sort(result, new WorkingSetComparator(true));
return result;
}
/**
* Adds newly created working sets to the list of all working sets.
*
* @param result the list of all working sets from the working set managers
* @since 3.7
*/
private void addNewlyCreatedWorkingSets(List<IWorkingSet> result) {
for (Iterator<IWorkingSet> iter= result.iterator(); iter.hasNext();) {
IWorkingSet set= iter.next();
if (!fAllWorkingSets.contains(set))
fAllWorkingSets.add(set);
}
}
/**
* Sets the working sets lists.
* <p>
* Note : All the active working sets must be contained in allWorkingSets and the relative
* ordering of the active working sets must be same in both allWorkingSets and activeWorkingSets
* arrays, else the method throws an <code>IllegalArgumentException</code.
* </p>
*
* @param allWorkingSets the array of all working sets
* @param isSortingEnabled <code>true</code> if sorting is enabled, <code>false</code> otherwise
* @param activeWorkingSets the array of active working sets
* @since 3.7
*/
public void setWorkingSets(IWorkingSet[] allWorkingSets, boolean isSortingEnabled, IWorkingSet[] activeWorkingSets) {
Assert.isLegal(Arrays.asList(allWorkingSets).containsAll(Arrays.asList(activeWorkingSets)));
Assert.isLegal(!isOrderDifferentInWorkingSetLists(Arrays.asList(allWorkingSets), Arrays.asList(activeWorkingSets)));
if (isSortingEnabled)
Arrays.sort(allWorkingSets, new WorkingSetComparator(true));
fAllWorkingSets= new ArrayList<IWorkingSet>(Arrays.asList(allWorkingSets));
setActiveWorkingSets(activeWorkingSets, isSortingEnabled);
}
/**
* Sets the active working sets.
* <p>
* Note: If the relative ordering of the active working sets is not same in both fAllWorkingSets
* and fActiveWorkingSets, fAllWorkingSets is re-ordered according to fActiveWorkingSets.
* </p>
*
* @param workingSets the active working sets to be set
*
*/
public void setActiveWorkingSets(IWorkingSet[] workingSets) {
Assert.isLegal(Arrays.asList(getAllWorkingSets()).containsAll(Arrays.asList(workingSets)));
if (fIsSortingEnabled) {
Arrays.sort(workingSets, new WorkingSetComparator(true));
}
fActiveWorkingSets= new ArrayList<IWorkingSet>(Arrays.asList(workingSets));
if (isOrderDifferentInWorkingSetLists(fAllWorkingSets, fActiveWorkingSets)) { //see bug 338531
adjustOrderingOfAllWorkingSets();
}
fElementMapper.rebuild(getActiveWorkingSets());
fOthersWorkingSetUpdater.updateElements();
fireEvent(new PropertyChangeEvent(this, CHANGE_WORKING_SET_MODEL_CONTENT, null, null));
}
/**
* Adjusts the relative ordering of the active working sets in fAllWorkingSets according to
* fActiveWorkingSets.
*
* @since 3.7
*/
private void adjustOrderingOfAllWorkingSets() {
int countActive= 0;
for (Iterator<IWorkingSet> iter= fAllWorkingSets.iterator(); iter.hasNext();) {
IWorkingSet set= iter.next();
if (fActiveWorkingSets.contains(set)) {
IWorkingSet workingSet= fActiveWorkingSets.get(countActive++);
if (!workingSet.equals(set)) {
int index= fAllWorkingSets.indexOf(workingSet);
fAllWorkingSets.set(fAllWorkingSets.indexOf(set), workingSet);
fAllWorkingSets.set(index, set);
}
if (countActive == fActiveWorkingSets.size())
return;
}
}
}
/**
* Checks if the order of active working sets is different in the active and all working set
* lists.
*
* @param allWorkingSets the list of all working sets
* @param activeWorkingSets the list of active working sets
* @return <code>true</code> if the order is different, <code>false</code> otherwise
* @since 3.7
*/
private boolean isOrderDifferentInWorkingSetLists(List<IWorkingSet> allWorkingSets, List<IWorkingSet> activeWorkingSets) {
int count= 0;
for (Iterator<IWorkingSet> iter= allWorkingSets.iterator(); iter.hasNext();) {
IWorkingSet set= iter.next();
if (activeWorkingSets.contains(set)) {
if (!activeWorkingSets.get(count++).equals(set))
return true;
}
}
return false;
}
/**
* Sets the active working sets.
*
* @param workingSets the array of working sets
* @param isSortingEnabled <code>true</code> if sorting is enabled, <code>false</code> otherwise
* @since 3.5
*/
public void setActiveWorkingSets(IWorkingSet[] workingSets, boolean isSortingEnabled) {
fIsSortingEnabled= isSortingEnabled;
setActiveWorkingSets(workingSets);
}
public void saveState(IMemento memento) {
memento.putBoolean(TAG_SORT_WORKING_SETS, fIsSortingEnabled);
memento.putBoolean(TAG_CONFIGURED, fConfigured);
fLocalWorkingSetManager.saveState(memento.createChild(TAG_LOCAL_WORKING_SET_MANAGER));
for (Iterator<IWorkingSet> iter= fActiveWorkingSets.iterator(); iter.hasNext();) {
IMemento active= memento.createChild(TAG_ACTIVE_WORKING_SET);
IWorkingSet workingSet= iter.next();
active.putString(TAG_WORKING_SET_NAME, workingSet.getName());
}
for (Iterator<IWorkingSet> iter= Arrays.asList(getAllWorkingSets()).iterator(); iter.hasNext();) {
IMemento allWorkingSet= memento.createChild(TAG_ALL_WORKING_SETS);
IWorkingSet workingSet= iter.next();
if (isSupportedAsTopLevelElement(workingSet))
allWorkingSet.putString(TAG_WORKING_SET_NAME, workingSet.getName());
}
}
public List<IAdaptable> getNonProjectTopLevelElements() {
return fElementMapper.getNonProjectTopLevelElements();
}
/**
* Restore localWorkingSetManager and active working sets.
*
* @param memento a memento
* @return whether the restore was successful
*/
private boolean restoreState(IMemento memento) {
String configured= memento.getString(TAG_CONFIGURED);
if (configured == null)
return false;
fConfigured= Boolean.valueOf(configured).booleanValue();
fLocalWorkingSetManager.restoreState(memento.getChild(TAG_LOCAL_WORKING_SET_MANAGER));
IWorkingSet[] allLocalWorkingSets= fLocalWorkingSetManager.getAllWorkingSets();
for (int i= 0; i < allLocalWorkingSets.length; i++) {
IWorkingSet ws= allLocalWorkingSets[i];
if (IWorkingSetIDs.OTHERS.equals(ws.getId())) {
// have to set the label again, since the locale could have been changed (bug 272737)
String otherProjectsLabel= WorkingSetMessages.WorkingSetModel_others_name;
if (! otherProjectsLabel.equals(ws.getLabel())) {
ws.setLabel(otherProjectsLabel);
}
}
}
String isSortingEnabled= memento.getString(TAG_SORT_WORKING_SETS);
if (isSortingEnabled == null) {
fIsSortingEnabled= false;
} else {
fIsSortingEnabled= Boolean.valueOf(isSortingEnabled).booleanValue();
}
IMemento[] actives= memento.getChildren(TAG_ACTIVE_WORKING_SET);
for (int i= 0; i < actives.length; i++) {
String name= actives[i].getString(TAG_WORKING_SET_NAME);
if (name != null) {
IWorkingSet ws= fLocalWorkingSetManager.getWorkingSet(name);
if (ws == null) {
ws= PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSet(name);
}
if (ws != null) {
fActiveWorkingSets.add(ws);
}
}
}
IMemento[] allWorkingSets= memento.getChildren(TAG_ALL_WORKING_SETS);
for (int i= 0; i < allWorkingSets.length; i++) {
String name= allWorkingSets[i].getString(TAG_WORKING_SET_NAME);
if (name != null) {
IWorkingSet ws= fLocalWorkingSetManager.getWorkingSet(name);
if (ws == null) {
ws= PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSet(name);
}
if (ws != null) {
fAllWorkingSets.add(ws);
}
}
}
List<IWorkingSet> result= getActiveAndAllWorkingSetsFromManagers();
if (!fAllWorkingSets.containsAll(result))
addNewlyCreatedWorkingSets(result);
return true;
}
private void workingSetManagerChanged(PropertyChangeEvent event) {
String property= event.getProperty();
if (IWorkingSetManager.CHANGE_WORKING_SET_UPDATER_INSTALLED.equals(property) && event.getSource() == fLocalWorkingSetManager) {
IWorkingSetUpdater updater= (IWorkingSetUpdater)event.getNewValue();
if (updater instanceof OthersWorkingSetUpdater) {
fOthersWorkingSetUpdater= (OthersWorkingSetUpdater)updater;
fOthersWorkingSetUpdater.init(this);
}
return;
}
// Add new working set to the list of active working sets and all working sets
if (IWorkingSetManager.CHANGE_WORKING_SET_ADD.equals(property)) {
IWorkingSet workingSet= (IWorkingSet)event.getNewValue();
if (isSupportedAsTopLevelElement(workingSet)) {
IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
List<IWorkingSet> allWorkingSets= new ArrayList<IWorkingSet>(Arrays.asList(manager.getAllWorkingSets()));
if (allWorkingSets.contains(workingSet)) {
List<IWorkingSet> elements= new ArrayList<IWorkingSet>(fActiveWorkingSets);
if (workingSet.isVisible() && !fActiveWorkingSets.contains(workingSet))
elements.add(workingSet);
List<IWorkingSet> allElements= new ArrayList<IWorkingSet>(Arrays.asList(getAllWorkingSets()));
if (!allElements.contains(workingSet))
allElements.add(workingSet);
setWorkingSets(allElements.toArray(new IWorkingSet[allElements.size()]), fIsSortingEnabled, elements.toArray(new IWorkingSet[elements.size()]));
}
}
}
// don't handle working sets not managed by the model
if (!isAffected(event))
return;
if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(property)) {
IWorkingSet workingSet= (IWorkingSet)event.getNewValue();
IAdaptable[] elements= fElementMapper.refresh(workingSet);
if (elements != null) {
fireEvent(event);
}
} else if (IWorkingSetManager.CHANGE_WORKING_SET_REMOVE.equals(property)) {
IWorkingSet workingSet= (IWorkingSet)event.getOldValue();
List<IWorkingSet> elements= new ArrayList<IWorkingSet>(fActiveWorkingSets);
elements.remove(workingSet);
List<IWorkingSet> allElements= new ArrayList<IWorkingSet>(Arrays.asList(getAllWorkingSets()));
allElements.remove(workingSet);
setWorkingSets(allElements.toArray(new IWorkingSet[allElements.size()]), fIsSortingEnabled, elements.toArray(new IWorkingSet[elements.size()]));
} else if (IWorkingSetManager.CHANGE_WORKING_SET_LABEL_CHANGE.equals(property)) {
IWorkingSet workingSet= (IWorkingSet)event.getNewValue();
if (isSortingEnabled() && Arrays.asList(getAllWorkingSets()).contains(workingSet)) {
setWorkingSets(getAllWorkingSets(), isSortingEnabled(), fActiveWorkingSets.toArray(new IWorkingSet[fActiveWorkingSets.size()]));
} else {
fireEvent(event);
}
}
}
/**
* Tells whether the given working set is supported as top-level element
*
* @param workingSet the working set to test
* @return <code>true</code> if the given working set is supported as top-level element
* @since 3.6
*/
public static boolean isSupportedAsTopLevelElement(IWorkingSet workingSet) {
Object id= workingSet.getId();
if (IWorkingSetIDs.OTHERS.equals(id) || IWorkingSetIDs.JAVA.equals(id) || IWorkingSetIDs.RESOURCE.equals(id))
return true;
if (!workingSet.isSelfUpdating() || workingSet.isAggregateWorkingSet())
return false;
IAdaptable[] elements= workingSet.getElements();
for (int i= 0; i < elements.length; i++) {
IAdaptable element= elements[i];
IProject p= (IProject)element.getAdapter(IProject.class);
if (p != null && p.exists())
return true;
}
return false;
}
private void fireEvent(PropertyChangeEvent event) {
Object[] listeners= fListeners.getListeners();
for (int i= 0; i < listeners.length; i++) {
((IPropertyChangeListener)listeners[i]).propertyChange(event);
}
}
private boolean isAffected(PropertyChangeEvent event) {
if (fActiveWorkingSets == null)
return false;
Object oldValue= event.getOldValue();
Object newValue= event.getNewValue();
if ((oldValue != null && fActiveWorkingSets.contains(oldValue))
|| (newValue != null && fActiveWorkingSets.contains(newValue))) {
return true;
}
return false;
}
public boolean isActiveWorkingSet(IWorkingSet changedWorkingSet) {
return fActiveWorkingSets.contains(changedWorkingSet);
}
public void addActiveWorkingSet(IWorkingSet workingSet) {
IWorkingSet[] workingSets= getActiveWorkingSets();
IWorkingSet[] activeWorkingSets= new IWorkingSet[workingSets.length+ 1];
System.arraycopy(workingSets, 0, activeWorkingSets, 0, workingSets.length);
activeWorkingSets[workingSets.length]= workingSet;
setActiveWorkingSets(activeWorkingSets);
}
/**
* Returns whether sorting is enabled for working sets.
*
* @return <code>true</code> if sorting is enabled, <code>false</code> otherwise
* @since 3.5
*/
public boolean isSortingEnabled() {
return fIsSortingEnabled;
}
}