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);
    }
}
 

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);
}
 

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);
		}
	}
}
 

/**
 * 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());
	}
}
 

@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);
		}
	});
}
 

@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);
	}
}
 

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);
	}
}
 

public WorkingSetFilterActionGroup(Shell shell, IWorkbenchPage page, IPropertyChangeListener changeListener) {
	Assert.isNotNull(shell);
	Assert.isNotNull(changeListener);

	fWorkbenchPage= page;
	fAllowWindowWorkingSetByDefault= false;
	fChangeListener= changeListener;
	fClearWorkingSetAction= new ClearWorkingSetAction(this);
	fSelectWorkingSetAction= new SelectWorkingSetAction(this, shell);
	fEditWorkingSetAction= new EditWorkingSetAction(this, shell);

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

	fWorkingSetFilter= new WorkingSetFilter();

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

	setWorkingSet(null, false);
}
 

@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);
}
 

/**
 * 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);
	}
}
 

/**
 * 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);
	}
}
 

/**
 * 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);
			}
		}
	}
}
 

/**
 * 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);
	}
}
 

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);
		}
	}
}
 

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);
		}
	}
}
 

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);
}
 

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();
	}
}
 

private void doWorkingSetChanged(PropertyChangeEvent event) {
	String property= event.getProperty();
	if (IWorkingSetManager.CHANGE_WORKING_SET_LABEL_CHANGE.equals(property))
		updateTitle();
	else	if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(property)) {
		updateTitle();
		fViewer.getControl().setRedraw(false);
		fViewer.refresh();
		fViewer.getControl().setRedraw(true);
	}

}
 

/**
 * {@inheritDoc}
 */
@Override
protected void cancelPressed() {
	IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
	for (int i= 0; i < fCreatedWorkingSets.size(); i++) {
		manager.removeWorkingSet(fCreatedWorkingSets.get(i));
	}

	super.cancelPressed();
}
 

private void editSelectedWorkingSet() {
	IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
	IWorkingSet editWorkingSet= (IWorkingSet)((IStructuredSelection)fTableViewer.getSelection()).getFirstElement();
	IWorkingSetEditWizard wizard= manager.createWorkingSetEditWizard(editWorkingSet);
	WizardDialog dialog= new WizardDialog(getShell(), wizard);
	IWorkingSet originalWorkingSet= fEditedWorkingSets.get(editWorkingSet);
	boolean firstEdit= originalWorkingSet == null;

	// save the original working set values for restoration when selection
	// dialog is cancelled.
	if (firstEdit) {
		originalWorkingSet=
			PlatformUI.getWorkbench().getWorkingSetManager().
			createWorkingSet(editWorkingSet.getName(), editWorkingSet.getElements());
	} else {
		fEditedWorkingSets.remove(editWorkingSet);
	}
	dialog.create();
	if (dialog.open() == Window.OK) {
		editWorkingSet= wizard.getSelection();
		if (fIsSortingEnabled)
			fTableViewer.refresh();
		else
			fTableViewer.update(editWorkingSet, null);

		// make sure ok button is enabled when the selected working set
		// is edited. Fixes bug 33386.
		updateButtonAvailability();
	}
	fEditedWorkingSets.put(editWorkingSet, originalWorkingSet);
}
 

/**
 * Removes newly created working sets from the working set manager.
 */
private void restoreAddedWorkingSets() {
	IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
	Iterator<IWorkingSet> iterator= fAddedWorkingSets.iterator();

	while (iterator.hasNext()) {
		manager.removeWorkingSet(iterator.next());
	}
}
 

/**
 * Adds back removed working sets to the working set manager.
 */
private void restoreRemovedWorkingSets() {
	IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager();
	Iterator<IWorkingSet> iterator= fRemovedWorkingSets.iterator();

	while (iterator.hasNext()) {
		manager.addWorkingSet(iterator.next());
	}
	iterator= fRemovedMRUWorkingSets.iterator();
	while (iterator.hasNext()) {
		manager.addRecentWorkingSet(iterator.next());
	}
}
 

/**
 * Sets this filter's working set.
 *
 * @param workingSet the working set
 * @param refreshViewer Indicates if the viewer should be refreshed.
 */
public void setWorkingSet(IWorkingSet workingSet, boolean refreshViewer) {
	// Update action
	fClearWorkingSetAction.setEnabled(workingSet != null);
	fEditWorkingSetAction.setEnabled(workingSet != null && !workingSet.isAggregateWorkingSet());

	fWorkingSet= workingSet;

	fWorkingSetFilter.setWorkingSet(workingSet);
	if (refreshViewer) {
		fChangeListener.propertyChange(new PropertyChangeEvent(this, IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE, null, workingSet));
	}
}
 

private void doPropertyChange(PropertyChangeEvent event) {
	String property= event.getProperty();
	if (IWorkingSetManager.CHANGE_WORKING_SET_LABEL_CHANGE.equals(property)) {
		fChangeListener.propertyChange(event);
	} else if  (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(property)) {
		IWorkingSet newWorkingSet= (IWorkingSet) event.getNewValue();
		if (newWorkingSet.equals(fWorkingSet)) {
			if (fWorkingSetFilter != null) {
				fWorkingSetFilter.notifyWorkingSetContentChange(); // first refresh the filter
			}
			fChangeListener.propertyChange(event);
		}
	}
}
 

public void propertyChange(PropertyChangeEvent event) {
	if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(event.getProperty())) {
		IWorkingSet changedWorkingSet= (IWorkingSet) event.getNewValue();
		if (changedWorkingSet != fWorkingSet && fWorkingSetModel.isActiveWorkingSet(changedWorkingSet)) {
			updateElements();
		}
	}
}
 

public void propertyChange(PropertyChangeEvent event) {
	String property = event.getProperty();
	Object newValue = event.getNewValue();
	Object oldValue = event.getOldValue();

	String newLabel = null;
	if (IWorkingSetManager.CHANGE_WORKING_SET_REMOVE.equals(property) && oldValue == workingSet) {
		newLabel = ""; //$NON-NLS-1$
		setWorkingSet(null);
	} else if (IWorkingSetManager.CHANGE_WORKING_SET_NAME_CHANGE.equals(property) && newValue == workingSet) {
		newLabel = workingSet.getLabel();
	} else if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(property) && newValue == workingSet) {
		if (workingSet.isAggregateWorkingSet() && workingSet.isEmpty()) {
			// act as if the working set has been made null
			if (!emptyWorkingSet) {
				emptyWorkingSet = true;
				setWorkingSetFilter(null);
				newLabel = null;
			}
		} else {
			// we've gone from empty to non-empty on our set.
			// Restore it.
			if (emptyWorkingSet) {
				emptyWorkingSet = false;
				setWorkingSetFilter(workingSet);
				newLabel = workingSet.getLabel();
			}
		}
	}
	if (viewer != null) {
		if (newLabel != null)
			viewer.getCommonNavigator().setWorkingSetLabel(newLabel);
		viewer.getFrameList().reset();
		viewer.refresh();
	}
}
 

/**
 * Set current active working set.
 * 
 * @param workingSet
 *            working set to be activated, may be <code>null</code>
 */
protected void setWorkingSet(IWorkingSet workingSet) {
	this.workingSet = workingSet;
	emptyWorkingSet = workingSet != null && workingSet.isAggregateWorkingSet() && workingSet.isEmpty();

       ignoreFilterChangeEvents = true;
       try {
       	workingSetActionGroup.setWorkingSet(workingSet);
       } finally {
       	ignoreFilterChangeEvents = false;
      	}		
	
	if (viewer != null) {
		setWorkingSetFilter(workingSet);
		if (workingSet == null || emptyWorkingSet
				|| !extensionStateModel.getBooleanProperty(WorkingSetsContentProvider.SHOW_TOP_LEVEL_WORKING_SETS)) {
			if (viewer.getInput() != originalViewerInput) {
				viewer.setInput(originalViewerInput);
			} else {
				viewer.refresh();
			}
		} else {
			if (!workingSet.isAggregateWorkingSet()) {
				IWorkingSetManager workingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
				viewer.setInput(workingSetManager.createAggregateWorkingSet(
						"", "", new IWorkingSet[] { workingSet })); //$NON-NLS-1$ //$NON-NLS-2$
			} else {
				viewer.setInput(workingSet);
			}
		}
	}
}
 

private void addToWorkingSets(IProject project) {
	IWorkingSet[] selectedWorkingSets = ((WizardNewHybridProjectCreationPage) pageOne).getSelectedWorkingSets();
	if(selectedWorkingSets == null || selectedWorkingSets.length == 0)
		return; // no Working set is selected
	IWorkingSetManager workingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
	workingSetManager.addToWorkingSets(project, selectedWorkingSets);
}
 

public void propertyChange(PropertyChangeEvent event) {
	String property = event.getProperty();
	Object newValue = event.getNewValue();
	Object oldValue = event.getOldValue();

	String newLabel = null;
	if (IWorkingSetManager.CHANGE_WORKING_SET_REMOVE.equals(property) && oldValue == workingSet) {
		newLabel = ""; //$NON-NLS-1$
		setWorkingSet(null);
	} else if (IWorkingSetManager.CHANGE_WORKING_SET_NAME_CHANGE.equals(property) && newValue == workingSet) {
		newLabel = workingSet.getLabel();
	} else if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(property) && newValue == workingSet) {
		if (workingSet.isAggregateWorkingSet() && workingSet.isEmpty()) {
			// act as if the working set has been made null
			if (!emptyWorkingSet) {
				emptyWorkingSet = true;
				setWorkingSetFilter(null);
				newLabel = null;
			}
		} else {
			// we've gone from empty to non-empty on our set.
			// Restore it.
			if (emptyWorkingSet) {
				emptyWorkingSet = false;
				setWorkingSetFilter(workingSet);
				newLabel = workingSet.getLabel();
			}
		}
	}
	if (viewer != null) {
		if (newLabel != null)
			viewer.getCommonNavigator().setWorkingSetLabel(newLabel);
		viewer.getFrameList().reset();
		viewer.refresh();
	}
}
 

/**
 * Set current active working set.
 * 
 * @param workingSet
 *            working set to be activated, may be <code>null</code>
 */
protected void setWorkingSet(IWorkingSet workingSet) {
	this.workingSet = workingSet;
	emptyWorkingSet = workingSet != null && workingSet.isAggregateWorkingSet() && workingSet.isEmpty();

       ignoreFilterChangeEvents = true;
       try {
       	workingSetActionGroup.setWorkingSet(workingSet);
       } finally {
       	ignoreFilterChangeEvents = false;
      	}		
	
	if (viewer != null) {
		setWorkingSetFilter(workingSet);
		if (workingSet == null || emptyWorkingSet
				|| !extensionStateModel.getBooleanProperty(WorkingSetsContentProvider.SHOW_TOP_LEVEL_WORKING_SETS)) {
			if (viewer.getInput() != originalViewerInput) {
				viewer.setInput(originalViewerInput);
			} else {
				viewer.refresh();
			}
		} else {
			if (!workingSet.isAggregateWorkingSet()) {
				IWorkingSetManager workingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
				viewer.setInput(workingSetManager.createAggregateWorkingSet(
						"", "", new IWorkingSet[] { workingSet })); //$NON-NLS-1$ //$NON-NLS-2$
			} else {
				viewer.setInput(workingSet);
			}
		}
	}
}