import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
void restoreWorkingSetsForProjects(List<WorkingSetData> workingSetDataList, List<IProject> projects,
		IWorkingSetManager mockedManager) {
	if (workingSetDataList == null || workingSetDataList.isEmpty()) {
		return;
	}
	if (projects == null || projects.isEmpty()) {
		return;
	}

	for (WorkingSetData data : workingSetDataList) {
		if (data.projectNamesContainedBefore.isEmpty()) {
			continue;
		}
		updateWorkingSet(data, projects);
	}

}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
/**
 * <p>
 * Adds the newly created project to the currently selected working set.
 * </p>
 * 
 * @param project the project to be added to the selected working set
 */
private void addProjectToSelectedWorkingSet(IProject project) {
	IWorkbench workbench = PlatformUI.getWorkbench();
	IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
	if (workbenchWindow == null) {
		return;
	}
	ISelectionService selectionService = workbenchWindow.getSelectionService();
	ISelection selection = selectionService.getSelection();
	if (selection instanceof IStructuredSelection) {
		IStructuredSelection structuredSelection = (IStructuredSelection) selection;
		Object firstElement = structuredSelection.getFirstElement();
		if (firstElement instanceof IAdaptable) {
			IAdaptable adaptable = (IAdaptable) firstElement;
			IWorkingSet workingSet = (IWorkingSet) adaptable.getAdapter(IWorkingSet.class);
			if (workingSet != null) {
				// new project wizard was invoked by right-clicking a working set
				IWorkingSetManager workingSetManager = workbench.getWorkingSetManager();
				workingSetManager.addToWorkingSets(project, new IWorkingSet[]{workingSet});
			}
		}
	}
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
private void selectWorkingSetAction() {
	IWorkingSetManager manager = PlatformUI.getWorkbench().getWorkingSetManager();
	IWorkingSetSelectionDialog dialog = manager.createWorkingSetSelectionDialog(getShell(), true);
	dialog.open();
	IWorkingSet[] sets = dialog.getSelection();
	if(sets != null) {
		workingSets = sets;
	} else {
		// dialog cancelled
		return;
	}
	updateWorkingSetScope();
	updateWorkingSetLabel();
	
	participantScope.setSelection(false);
	selectedResourcesScope.setSelection(false);
	workingSetScope.setSelection(true);
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
private void createWorkingSet() {
	IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
	IWorkingSetNewWizard wizard= manager.createWorkingSetNewWizard(new String[] {IWorkingSetIDs.JAVA});
	// the wizard can't be null since we have at least the Java working set.
	WizardDialog dialog= new WizardDialog(getShell(), wizard);
	dialog.create();
	if (dialog.open() == Window.OK) {
		IWorkingSet workingSet= wizard.getSelection();
		if (WorkingSetModel.isSupportedAsTopLevelElement(workingSet)) {
			fAllWorkingSets.add(workingSet);
			fTableViewer.add(workingSet);
			fTableViewer.setSelection(new StructuredSelection(workingSet), true);
			fTableViewer.setChecked(workingSet, true);
			manager.addWorkingSet(workingSet);
			fAddedWorkingSets.add(workingSet);
		}
	}
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
/**
 * Removes the selected working sets from the workbench.
 */
private void removeSelectedWorkingSets() {
	ISelection selection= fTableViewer.getSelection();
	if (selection instanceof IStructuredSelection) {
		IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
		Iterator<?> iter= ((IStructuredSelection)selection).iterator();
		while (iter.hasNext()) {
			IWorkingSet workingSet= (IWorkingSet)iter.next();
			if (fAddedWorkingSets.contains(workingSet)) {
				fAddedWorkingSets.remove(workingSet);
			} else {
				IWorkingSet[] recentWorkingSets= manager.getRecentWorkingSets();
				for (int i= 0; i < recentWorkingSets.length; i++) {
					if (workingSet.equals(recentWorkingSets[i])) {
						fRemovedMRUWorkingSets.add(workingSet);
						break;
					}
				}
				fRemovedWorkingSets.add(workingSet);
			}
			fAllWorkingSets.remove(workingSet);
			manager.removeWorkingSet(workingSet);
		}
		fTableViewer.remove(((IStructuredSelection)selection).toArray());
	}
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
@Override
public void fill(Menu menu, int index) {
	MenuItem mi= new MenuItem(menu, SWT.RADIO, index);

	String name= fWorkingSet.getLabel();

	mi.setText("&" + fId + " " + name);  //$NON-NLS-1$  //$NON-NLS-2$
	if (fImage == null) {
		ImageDescriptor imageDescriptor= fWorkingSet.getImageDescriptor();
		if (imageDescriptor != null)
			fImage= imageDescriptor.createImage();
	}
	mi.setImage(fImage);
	mi.setSelection(fWorkingSet.equals(fActionGroup.getWorkingSet()));
	mi.addSelectionListener(new SelectionAdapter() {
		@Override
		public void widgetSelected(SelectionEvent e) {
			IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
			fActionGroup.setWorkingSet(fWorkingSet, true);
			manager.addRecentWorkingSet(fWorkingSet);
		}
	});
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
@Override
public void run() {
	Shell shell= getShell();
	IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
	IWorkingSetSelectionDialog dialog= manager.createWorkingSetSelectionDialog(shell, false);
	IWorkingSet workingSet= fActionGroup.getWorkingSet();
	if (workingSet != null)
		dialog.setSelection(new IWorkingSet[]{workingSet});

	if (dialog.open() == Window.OK) {
		IWorkingSet[] result= dialog.getSelection();
		if (result != null && result.length > 0) {
			fActionGroup.setWorkingSet(result[0], true);
			manager.addRecentWorkingSet(result[0]);
		}
		else
			fActionGroup.setWorkingSet(null, true);
	}
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
public WorkingSetFilterActionGroup(IWorkbenchPartSite site, IPropertyChangeListener changeListener) {
	Assert.isNotNull(site);
	Assert.isNotNull(changeListener);

	fChangeListener= changeListener;
	fWorkbenchPage= site.getPage();
	fAllowWindowWorkingSetByDefault= true;
	fClearWorkingSetAction= new ClearWorkingSetAction(this);
	fSelectWorkingSetAction= new SelectWorkingSetAction(this, site);
	fEditWorkingSetAction= new EditWorkingSetAction(this, site);

	fWorkingSetListener= new IPropertyChangeListener() {
		public void propertyChange(PropertyChangeEvent event) {
			doPropertyChange(event);
		}
	};
	fWorkingSetFilter= new WorkingSetFilter();

	IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
	manager.addPropertyChangeListener(fWorkingSetListener);

	if (useWindowWorkingSetByDefault()) {
		setWorkingSet(site.getPage().getAggregateWorkingSet(), false);
	}
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
@Override
public void run() {
	Shell shell= getShell();
	IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
	IWorkingSet workingSet= fActionGroup.getWorkingSet();
	if (workingSet == null || workingSet.isAggregateWorkingSet()) {
		setEnabled(false);
		return;
	}
	IWorkingSetEditWizard wizard= manager.createWorkingSetEditWizard(workingSet);
	if (wizard == null) {
		String title= WorkingSetMessages.EditWorkingSetAction_error_nowizard_title;
		String message= WorkingSetMessages.EditWorkingSetAction_error_nowizard_message;
		MessageDialog.openError(shell, title, message);
		return;
	}
	WizardDialog dialog= new WizardDialog(shell, wizard);
 	dialog.create();
	if (dialog.open() == Window.OK)
		fActionGroup.setWorkingSet(wizard.getSelection(), true);
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
/**
 * Restores the working set filter from the persistence store.
 */
protected void initWorkingSetFilter(String workingSetName) {
	IWorkingSet workingSet = null;

	if (workingSetName != null && workingSetName.length() > 0) {
		IWorkingSetManager workingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
		workingSet = workingSetManager.getWorkingSet(workingSetName);
	} else if (PlatformUI.getPreferenceStore().getBoolean(
			IWorkbenchPreferenceConstants.USE_WINDOW_WORKING_SET_BY_DEFAULT)) {
		// use the window set by default if the global preference is set
		workingSet = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getAggregateWorkingSet();
	}

	if (workingSet != null) {
		setWorkingSet(workingSet);
	}
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
protected void initWorkingSet(String workingSetName) {
    IWorkingSet workingSet = null;

    if (workingSetName != null && workingSetName.length() > 0) {
        IWorkingSetManager workingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
        workingSet = workingSetManager.getWorkingSet(workingSetName);
    } /*
       * else if (PlatformUI.getPreferenceStore().getBoolean(
       * IWorkbenchPreferenceConstants.USE_WINDOW_WORKING_SET_BY_DEFAULT)) {
       * // use the window set by default if the global preference is set
       * workingSet =
       * PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage
       * ().getAggregateWorkingSet(); }
       */
    if (workingSet != null) {
        setCurrentWorkingSet(workingSet);
    }
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
private void createWorkingSet(IWorkingSet[] workingSets, IProject[] projects) {
	IWorkingSetManager manager = PsfImportPlugin.getDefault().getWorkbench().getWorkingSetManager();
	String workingSetName;
	for (int i = 0; i < workingSets.length; i++) {
		workingSetName = workingSets[i].getName();
		IWorkingSet oldSet = manager.getWorkingSet(workingSetName);
		if (oldSet == null) {
			IWorkingSet newSet = manager.createWorkingSet(workingSetName, projects);
			manager.addWorkingSet(newSet);
		} else {
			// don't overwrite the old elements
			IAdaptable[] tempElements = oldSet.getElements();
			IAdaptable[] adaptedProjects = oldSet.adaptElements(projects);
			IAdaptable[] finalElementList = new IAdaptable[tempElements.length + adaptedProjects.length];
			System.arraycopy(tempElements, 0, finalElementList, 0, tempElements.length);
			System.arraycopy(adaptedProjects, 0, finalElementList, tempElements.length, adaptedProjects.length);
			oldSet.setElements(finalElementList);
		}
	}
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
/**
 * Resets the state of all Eclipse based working sets that belong to the 'Resources' type.
 */
private void resetEclipseWorkingSetsBaseOnCurrentState() {
	try {
		if (getWorkbench() == null || getWorkbench().getWorkingSetManager() == null) {
			return; // happens during shutdown
		}

		// Removed listener otherwise due to the Eclipse based working set deletion
		// we would delete our content.
		getWorkbench().getWorkingSetManager().removePropertyChangeListener(this);

		deleteEclipseResourcesWorkingSets();
		final IWorkingSetManager manager = getWorkbench().getWorkingSetManager();
		for (final WorkingSet workingSet : getAllWorkingSets()) {
			if (!OTHERS_WORKING_SET_ID.equals(workingSet.getId())) {
				org.eclipse.ui.internal.WorkingSet eclipseWorkingSet = createEclipseWorkingSet(workingSet);
				eclipseWorkingSet.setId(WorkingSetManagerModificationStrategy.RESOURCE_WORKING_SET_ID);
				manager.addWorkingSet(eclipseWorkingSet);
			}
		}
	} finally {
		IWorkbench wb = getWorkbench();
		if (wb != null) {
			IWorkingSetManager wsm = wb.getWorkingSetManager();
			if (wsm != null) { // null-safe re-adding (can be null during shutdown)
				wsm.addPropertyChangeListener(this);
			}
		}
	}
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
/**
 * Deletes all Eclipse based working sets that belong to the 'Resources' working set type.
 */
private void deleteEclipseResourcesWorkingSets() {
	// Discard the Eclipse based working set manager state by deleting all 'Resources' working sets.
	final Iterator<IWorkingSet> itr = getAllEclipseResourceWorkingSetsIterator();
	final IWorkingSetManager manager = getWorkbench().getWorkingSetManager();
	while (itr.hasNext()) {
		final IWorkingSet next = itr.next();
		manager.removeWorkingSet(next);
	}
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
private void addToWorkingSet(IProject project) {
    IWorkingSet[] selectedWorkingSets = workingSetGroup.getSelectedWorkingSets();
    if (selectedWorkingSets.length != 0) {
        IWorkingSetManager workingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
        workingSetManager.addToWorkingSets(project, selectedWorkingSets);
    }
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
private void initializeScopingHint() {
	String working_sets = settings.get(STORE_WORKING_SETS);
	if (working_sets == null) {
		participantScope.setSelection(true);
		updateParticipantScope();
	} else {
		StringTokenizer st = new StringTokenizer(working_sets, " ,"); //$NON-NLS-1$
		ArrayList ws = new ArrayList();
		while (st.hasMoreTokens()) {
			String workingSetName = st.nextToken();
			if (workingSetName != null && workingSetName.equals("") == false) { //$NON-NLS-1$
				IWorkingSetManager workingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
				IWorkingSet workingSet = workingSetManager.getWorkingSet(workingSetName);
				if (workingSet != null) {
					ws.add(workingSet);
				}
			}
		}
		if(! ws.isEmpty()) {
			this.workingSets = (IWorkingSet[]) ws.toArray(new IWorkingSet[ws.size()]);
			updateWorkingSetScope();
			updateWorkingSetLabel();			
			participantScope.setSelection(false);
			selectedResourcesScope.setSelection(false);
			workingSetScope.setSelection(true);
		}
	}
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
@SuppressWarnings("unused")
private void addToWorkingSets() {		
	if(workingSetGroup != null){
		IWorkingSet[] selectedWorkingSets = workingSetGroup.getSelectedWorkingSets();
		if(selectedWorkingSets == null || selectedWorkingSets.length == 0)
			return; // no Working set is selected
		IWorkingSetManager workingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
		for (Iterator i = createdProjects.iterator(); i.hasNext();) {
			IProject project = (IProject) i.next();
			workingSetManager.addToWorkingSets(project, selectedWorkingSets);
		}
	}
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
private void doWorkingSetChanged(PropertyChangeEvent event) {
	if (ViewActionGroup.MODE_CHANGED.equals(event.getProperty())) {
		fPart.rootModeChanged(((Integer)event.getNewValue()).intValue());
		Object oldInput= null;
		Object newInput= null;
		if (fPart.getRootMode() == PackageExplorerPart.PROJECTS_AS_ROOTS) {
			oldInput= fPart.getWorkingSetModel();
			newInput= JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
		} else {
			oldInput= JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
			newInput= fPart.getWorkingSetModel();
		}
		if (oldInput != null && newInput != null) {
			Frame frame;
			for (int i= 0; (frame= fFrameList.getFrame(i)) != null; i++) {
				if (frame instanceof TreeFrame) {
					TreeFrame treeFrame= (TreeFrame)frame;
					if (oldInput.equals(treeFrame.getInput()))
						treeFrame.setInput(newInput);
				}
			}
		}
	} else {
		IWorkingSet workingSet= (IWorkingSet) event.getNewValue();

		String workingSetLabel= null;
		if (workingSet != null)
			workingSetLabel= BasicElementLabels.getWorkingSetLabel(workingSet);
		fPart.setWorkingSetLabel(workingSetLabel);
		fPart.updateTitle();

		String property= event.getProperty();
		if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(property)) {
			TreeViewer viewer= fPart.getTreeViewer();
			viewer.getControl().setRedraw(false);
			viewer.refresh();
			viewer.getControl().setRedraw(true);
		}
	}
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
private void workingSetModelChanged(PropertyChangeEvent event) {
	String property= event.getProperty();
	Object newValue= event.getNewValue();
	List<Object> toRefresh= new ArrayList<Object>(1);
	if (WorkingSetModel.CHANGE_WORKING_SET_MODEL_CONTENT.equals(property)) {
		toRefresh.add(fWorkingSetModel);
	} else if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(property)) {
		toRefresh.add(newValue);
	} else if (IWorkingSetManager.CHANGE_WORKING_SET_LABEL_CHANGE.equals(property)) {
		toRefresh.add(newValue);
	}
	ArrayList<Runnable> runnables= new ArrayList<Runnable>();
	postRefresh(toRefresh, true, runnables);
	executeRunnables(runnables);
}
 

import org.eclipse.ui.IWorkingSetManager; //导入依赖的package包/类
protected void doPropertyChange(PropertyChangeEvent event) {
	String property= event.getProperty();
	if (fMethodsViewer != null) {
		if (MembersOrderPreferenceCache.isMemberOrderProperty(event.getProperty())) {
			fMethodsViewer.refresh();
		}
	}
	if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(property)) {
		updateHierarchyViewer(true);
		updateToolTipAndDescription();
	}
}