org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/workingsets/ConfigureWorkingSetAssignementAction.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2007 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.HashSet;
 import java.util.Hashtable;
 import java.util.Iterator;
 import java.util.List;

 import org.eclipse.core.runtime.IAdaptable;

 import org.eclipse.core.resources.IResource;

 import org.eclipse.swt.SWT;
 import org.eclipse.swt.events.SelectionAdapter;
 import org.eclipse.swt.events.SelectionEvent;
 import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.Button;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Link;
 import org.eclipse.swt.widgets.Shell;

 import org.eclipse.jface.dialogs.IDialogConstants;
 import org.eclipse.jface.viewers.CheckStateChangedEvent;
 import org.eclipse.jface.viewers.CheckboxTableViewer;
 import org.eclipse.jface.viewers.ICheckStateListener;
 import org.eclipse.jface.viewers.IStructuredSelection;
 import org.eclipse.jface.viewers.LabelProvider;
 import org.eclipse.jface.viewers.StructuredSelection;
 import org.eclipse.jface.viewers.Viewer;
 import org.eclipse.jface.viewers.ViewerFilter;
 import org.eclipse.jface.viewers.ViewerSorter;
 import org.eclipse.jface.window.Window;

 import org.eclipse.ui.IWorkbenchPage;
 import org.eclipse.ui.IWorkbenchPart;
 import org.eclipse.ui.IWorkbenchSite;
 import org.eclipse.ui.IWorkingSet;
 import org.eclipse.ui.PlatformUI;

 import org.eclipse.jdt.core.IJavaElement;

 import org.eclipse.jdt.internal.corext.util.Messages;

 import org.eclipse.jdt.ui.JavaElementLabels;
 import org.eclipse.jdt.ui.actions.SelectionDispatchAction;

 import org.eclipse.jdt.internal.ui.JavaPlugin;
 import org.eclipse.jdt.internal.ui.packageview.PackageExplorerPart;

 public final class ConfigureWorkingSetAssignementAction extends SelectionDispatchAction {

 	private static final class GrayedCheckedModel {

 		private GrayedCheckedModelElement[] fElements;
 		private final Hashtable fLookup;

 		public GrayedCheckedModel(GrayedCheckedModelElement[] elements) {
 			fElements= elements;
 			fLookup= new Hashtable();
 			for (int i= 0; i < elements.length; i++) {
 				fLookup.put(elements[i].getWorkingSet(), elements[i]);
 			}
 		}

 		public void addElement(GrayedCheckedModelElement element) {
 			ArrayList list= new ArrayList(Arrays.asList(fElements));
 			list.add(element);
 			fElements= (GrayedCheckedModelElement[])list.toArray(new GrayedCheckedModelElement[list.size()]);

 			fLookup.put(element.getWorkingSet(), element);
 		}

 		public IWorkingSet[] getAll() {
 			IWorkingSet[] result= new IWorkingSet[fElements.length];
 			for (int i= 0; i < fElements.length; i++) {
 				result[i]= fElements[i].getWorkingSet();
 			}
 			return result;
 		}

 		public GrayedCheckedModelElement getModelElement(IWorkingSet element) {
 			return (GrayedCheckedModelElement)fLookup.get(element);
 		}

 		public IWorkingSet[] getChecked() {
 			ArrayList result= new ArrayList();
 			for (int i= 0; i < fElements.length; i++) {
 				if (fElements[i].isChecked())
 					result.add(fElements[i].getWorkingSet());
 			}
 			return (IWorkingSet[])result.toArray(new IWorkingSet[result.size()]);
 		}

 		public IWorkingSet[] getGrayed() {
 			ArrayList result= new ArrayList();
 			for (int i= 0; i < fElements.length; i++) {
 				if (fElements[i].isGrayed())
 					result.add(fElements[i].getWorkingSet());
 			}
 			return (IWorkingSet[])result.toArray(new IWorkingSet[result.size()]);
 		}

 		public void selectAll() {
 			for (int i= 0; i < fElements.length; i++) {
 				fElements[i].select();
 			}
 		}

 		public void deselectAll() {
 			for (int i= 0; i < fElements.length; i++) {
 				fElements[i].deselect();
 			}
 		}

 	}

 	private final static class GrayedCheckedModelElement {

 		private final IWorkingSet fWorkingSet;
 		private final int fElementCount;
 		private int fCheckCount;

 		public GrayedCheckedModelElement(IWorkingSet workingSet, int checkCount, int elementCount) {
 			fWorkingSet= workingSet;
 			fCheckCount= checkCount;
 			fElementCount= elementCount;
 		}

 		public IWorkingSet getWorkingSet() {
 			return fWorkingSet;
 		}

 		public int getCheckCount() {
 			return fCheckCount;
 		}

 		public boolean isGrayed() {
 			return isChecked() && fCheckCount < fElementCount;
 		}

 		public boolean isChecked() {
 			return fCheckCount > 0;
 		}

 		public void deselect() {
 			fCheckCount= 0;
 		}

 		public void select() {
 			fCheckCount= fElementCount;
 		}

 	}

 	private final class WorkingSetModelAwareSelectionDialog extends SimpleWorkingSetSelectionDialog {

 		private CheckboxTableViewer fTableViewer;
 		private boolean fShowVisibleOnly;
 		private GrayedCheckedModel fModel;
 		private final IAdaptable[] fElements;

 		private WorkingSetModelAwareSelectionDialog(Shell shell, GrayedCheckedModel model, IAdaptable[] elements) {
 			super(shell, VALID_WORKING_SET_IDS, model.getChecked());
 			setTitle(WorkingSetMessages.ConfigureWorkingSetAssignementAction_WorkingSetAssignments_title);
 			fModel= model;
 			fShowVisibleOnly= true;
 			fElements= elements;
 		}

 		public IWorkingSet[] getGrayed() {
 			return fModel.getGrayed();
 		}

 		public IWorkingSet[] getSelection() {
 			return fModel.getChecked();
 		}

 		protected CheckboxTableViewer createTableViewer(Composite parent) {
 			fTableViewer= super.createTableViewer(parent);
 			fTableViewer.setGrayedElements(fModel.getGrayed());
 			fTableViewer.addCheckStateListener(new ICheckStateListener() {
 				public void checkStateChanged(CheckStateChangedEvent event) {
 					IWorkingSet element= (IWorkingSet)event.getElement();
 					fTableViewer.setGrayed(element, false);
 					GrayedCheckedModelElement modelElement= fModel.getModelElement(element);
 					if (event.getChecked()) {
 						modelElement.select();
 					} else {
 						modelElement.deselect();
 					}
 					fTableViewer.update(element, null);
 				}
 			});

 			createShowVisibleOnly(parent);

 			return fTableViewer;
 		}

 		protected void selectAll() {
 			super.selectAll();
 			fModel.selectAll();
 			fTableViewer.setGrayedElements(new Object[0]);
 			fTableViewer.refresh();
 		}

 		protected void deselectAll() {
 			super.deselectAll();
 			fModel.deselectAll();
 			fTableViewer.setGrayedElements(new Object[0]);
 			fTableViewer.refresh();
 		}

 		/**
 		 * {@inheritDoc}
 		 */
 		protected void addNewWorkingSet(IWorkingSet workingSet) {
 			if (fWorkingSetModel != null) {
 				IWorkingSet[] workingSets= fWorkingSetModel.getActiveWorkingSets();
 				IWorkingSet[] activeWorkingSets= new IWorkingSet[workingSets.length+ 1];
 				activeWorkingSets[0]= workingSet;
 				System.arraycopy(workingSets, 0, activeWorkingSets, 1, workingSets.length);
 				fWorkingSetModel.setActiveWorkingSets(activeWorkingSets);
 			}

 			int checkCount= 0;
 			for (int i= 0; i < fElements.length; i++) {
 				IAdaptable adapted= adapt(workingSet, fElements[i]);
 				if (adapted != null && contains(workingSet, adapted)) {
 					checkCount++;
 				}
 			}

 			fModel.addElement(new GrayedCheckedModelElement(workingSet, checkCount, fElements.length));

 			fTableViewer.setInput(fModel.getAll());
 			fTableViewer.refresh();

 			fTableViewer.setCheckedElements(fModel.getChecked());
 			fTableViewer.setGrayedElements(fModel.getGrayed());

 			fTableViewer.setSelection(new StructuredSelection(workingSet));
 		}

 		protected ViewerFilter createTableFilter() {
 			final ViewerFilter superFilter= super.createTableFilter();
 			return new ViewerFilter() {
 				public boolean select(Viewer viewer, Object parentElement, Object element) {
 					if (!superFilter.select(viewer, parentElement, element))
 						return false;

 					IWorkingSet set= (IWorkingSet)element;
 					if (!isValidWorkingSet(set))
 						return false;

 					if (fWorkingSetModel == null)
 						return true;

 					if (fShowVisibleOnly) {
 						if (!fWorkingSetModel.isActiveWorkingSet(set))
 							return false;

 						return true;
 					} else {
 						return true;
 					}
 				}
 			};
 		}

 		protected ViewerSorter createTableSorter() {
 			final ViewerSorter superSorter= super.createTableSorter();
 			return new ViewerSorter() {
 				public int compare(Viewer viewer, Object e1, Object e2) {
 					if (fWorkingSetModel == null)
 						return superSorter.compare(viewer, e1, e2);

 					IWorkingSet[] activeWorkingSets= fWorkingSetModel.getActiveWorkingSets();
 					for (int i= 0; i < activeWorkingSets.length; i++) {
 						IWorkingSet active= activeWorkingSets[i];
 						if (active == e1) {
 							return -1;
 						} else if (active == e2) {
 							return 1;
 						}
 					}

 					return superSorter.compare(viewer, e1, e2);
 				}
 			};
 		}

 		protected LabelProvider createTableLabelProvider() {
 			final LabelProvider superLabelProvider= super.createTableLabelProvider();
 			return new LabelProvider() {
 				public String getText(Object element) {
 					String superText= superLabelProvider.getText(element);
 					if (superText == null)
 						return null;

 					GrayedCheckedModelElement modelElement= fModel.getModelElement((IWorkingSet)element);
 					if (!modelElement.isGrayed())
 						return superText;

 					return superText + Messages.format(WorkingSetMessages.ConfigureWorkingSetAssignementAction_XofY_label, new Object[] {new Integer(modelElement.getCheckCount()), new Integer(fElements.length)});
 				}
 			};
 		}

 		private void createShowVisibleOnly(Composite parent) {
 			if (fWorkingSetModel == null)
 				return;

 			Composite bar= new Composite(parent, SWT.NONE);
 			bar.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
 			GridLayout gridLayout= new GridLayout(2, false);
 			gridLayout.marginHeight= 0;
 			gridLayout.marginWidth= 0;
 			bar.setLayout(gridLayout);

 			final Button showVisibleOnly= new Button(bar, SWT.CHECK);
 			showVisibleOnly.setSelection(fShowVisibleOnly);
 			showVisibleOnly.setLayoutData(new GridData(SWT.LEAD, SWT.FILL, false, true));
 			showVisibleOnly.addSelectionListener(new SelectionAdapter() {
 				public void widgetSelected(SelectionEvent e) {
 					fShowVisibleOnly= showVisibleOnly.getSelection();

 					fTableViewer.refresh();

 					fTableViewer.setCheckedElements(fModel.getChecked());
 					fTableViewer.setGrayedElements(fModel.getGrayed());
 				}
 			});

 			Link ppwsLink= new Link(bar, SWT.NONE);
 			ppwsLink.setText(WorkingSetMessages.ConfigureWorkingSetAssignementAction_OnlyShowVisible_link);
 			ppwsLink.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 			ppwsLink.addSelectionListener(new SelectionAdapter() {
 				public void widgetSelected(SelectionEvent e) {

 					List workingSets= new ArrayList(Arrays.asList(fWorkingSetModel.getAllWorkingSets()));
 					IWorkingSet[] activeWorkingSets= fWorkingSetModel.getActiveWorkingSets();
 					WorkingSetConfigurationDialog dialog= new WorkingSetConfigurationDialog(
 						getShell(),
 						(IWorkingSet[])workingSets.toArray(new IWorkingSet[workingSets.size()]),
 						activeWorkingSets);
 					dialog.setSelection(activeWorkingSets);
 					if (dialog.open() == IDialogConstants.OK_ID) {
 						IWorkingSet[] selection= dialog.getSelection();
 						fWorkingSetModel.setActiveWorkingSets(selection);
 					}

 					recalculateCheckedState();
 				}
 			});
 		}

 		private void recalculateCheckedState() {
 			fModel= createGrayedCheckedModel(fElements, getAllWorkingSets());

 			fTableViewer.setInput(fModel.getAll());
 			fTableViewer.refresh();
 			fTableViewer.setCheckedElements(fModel.getChecked());
 			fTableViewer.setGrayedElements(fModel.getGrayed());
 		}
 	}

 	private static final String[] VALID_WORKING_SET_IDS= new String[] {
 			JavaWorkingSetUpdater.ID,
 			"org.eclipse.ui.resourceWorkingSetPage" //$NON-NLS-1$
 	};

 	private WorkingSetModel fWorkingSetModel;
 	private final IWorkbenchSite fSite;

 	public ConfigureWorkingSetAssignementAction(IWorkbenchSite site) {
 		super(site);
 		fSite= site;
 		setText(WorkingSetMessages.ConfigureWorkingSetAssignementAction_WorkingSets_actionLabel);
 		setEnabled(false);
 	}

 	public void setWorkingSetModel(WorkingSetModel workingSetModel) {
 		fWorkingSetModel= workingSetModel;
 	}

 	public void selectionChanged(IStructuredSelection selection) {
 		setEnabled(canEnable(selection));
 	}

 	private boolean canEnable(IStructuredSelection selection) {
 		if (selection.isEmpty())
 			return false;

 		List list= selection.toList();
 		for (Iterator iterator= list.iterator(); iterator.hasNext();) {
 			Object object= iterator.next();
 			if (!(object instanceof IResource) && !(object instanceof IJavaElement))
 				return false;
 		}

 		return true;
 	}

 	private IAdaptable[] getSelectedElements(IStructuredSelection selection) {
 		ArrayList result= new ArrayList();

 		List list= selection.toList();
 		for (Iterator iterator= list.iterator(); iterator.hasNext();) {
 			Object object= iterator.next();
 			if (object instanceof IResource || object instanceof IJavaElement) {
 				result.add(object);
 			}
 		}

 		return (IAdaptable[])result.toArray(new IAdaptable[result.size()]);
 	}

 	public void run(IStructuredSelection selection) {
 		IAdaptable[] elements= getSelectedElements(selection);
 		GrayedCheckedModel model= createGrayedCheckedModel(elements, getAllWorkingSets());
 		WorkingSetModelAwareSelectionDialog dialog= new WorkingSetModelAwareSelectionDialog(fSite.getShell(), model, elements);

 		if (elements.length == 1) {
 			IAdaptable element= elements[0];
 			String elementName;
 			if (element instanceof IResource) {
 				elementName= ((IResource)element).getName();
 			} else {
 				elementName= JavaElementLabels.getElementLabel((IJavaElement)element, JavaElementLabels.ALL_DEFAULT);
 			}
 			dialog.setMessage(Messages.format(WorkingSetMessages.ConfigureWorkingSetAssignementAction_DialogMessage_specific, elementName));
 		} else {
 			dialog.setMessage(Messages.format(WorkingSetMessages.ConfigureWorkingSetAssignementAction_DialogMessage_multi, new Integer(elements.length)));
 		}
 		if (dialog.open() == Window.OK) {
 			updateWorkingSets(dialog.getSelection(), dialog.getGrayed(), elements);
 			selectAndReveal(elements);
 		}
 	}

 	private static GrayedCheckedModel createGrayedCheckedModel(IAdaptable[] elements, IWorkingSet[] workingSets) {
 		GrayedCheckedModelElement[] result= new GrayedCheckedModelElement[workingSets.length];

 		for (int i= 0; i < workingSets.length; i++) {
 			IWorkingSet set= workingSets[i];

 			int checkCount= 0;
 			for (int j= 0; j < elements.length; j++) {
 				IAdaptable adapted= adapt(set, elements[j]);
 				if (adapted != null && contains(set, adapted)) {
 					checkCount++;
 				}
 			}

 			result[i]= new GrayedCheckedModelElement(set, checkCount, elements.length);
 		}

 		return new GrayedCheckedModel(result);
 	}

 	private void updateWorkingSets(IWorkingSet[] newWorkingSets, IWorkingSet[] grayedWorkingSets, IAdaptable[] elements) {
 		HashSet selectedSets= new HashSet(Arrays.asList(newWorkingSets));
 		HashSet grayedSets= new HashSet(Arrays.asList(grayedWorkingSets));
 		IWorkingSet[] workingSets= getAllWorkingSets();

 		for (int i= 0; i < workingSets.length; i++) {
 			IWorkingSet workingSet= workingSets[i];
 			if (isValidWorkingSet(workingSet) && !selectedSets.contains(workingSet) && !grayedSets.contains(workingSet)) {
 				for (int j= 0; j < elements.length; j++) {
 					IAdaptable adapted= adapt(workingSet, elements[j]);
 					if (adapted != null && contains(workingSet, adapted)) {
 						remove(workingSet, adapted);
 					}
 				}
 			}
 		}

 		for (int i= 0; i < newWorkingSets.length; i++) {
 			IWorkingSet set= newWorkingSets[i];
 			if (isValidWorkingSet(set) && !grayedSets.contains(set)) {
 				for (int j= 0; j < elements.length; j++) {
 					IAdaptable adapted= adapt(set, elements[j]);
 					if (adapted != null && !contains(set, adapted)) {
 						add(set, adapted);
 					}
 				}
 			}
 		}
 	}

 	private IWorkingSet[] getAllWorkingSets() {
 		if (fWorkingSetModel != null) {
 			return fWorkingSetModel.getAllWorkingSets();
 		} else {
 			return PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSets();
 		}
 	}

 	private static boolean isValidWorkingSet(IWorkingSet set) {
 		if (set.isAggregateWorkingSet() || !set.isSelfUpdating())
 			return false;

 		if (!set.isVisible())
 			return false;

 		if (!set.isEditable())
 			return false;

 		for (int i= 0; i < VALID_WORKING_SET_IDS.length; i++) {
 			if (VALID_WORKING_SET_IDS[i].equals(set.getId()))
 				return true;
 		}

 		return false;
 	}

 	private static IAdaptable adapt(IWorkingSet set, IAdaptable element) {
 		IAdaptable[] adaptedElements= set.adaptElements(new IAdaptable[] {
 			element
 		});
 		if (adaptedElements.length != 1)
 			return null;

 		return adaptedElements[0];
 	}

 	private static boolean contains(IWorkingSet set, IAdaptable adaptedElement) {
 		IAdaptable[] elements= set.getElements();
 		for (int i= 0; i < elements.length; i++) {
 			if (elements[i].equals(adaptedElement))
 				return true;
 		}

 		return false;
 	}

 	private static void remove(IWorkingSet workingSet, IAdaptable adaptedElement) {
 		HashSet set= new HashSet(Arrays.asList(workingSet.getElements()));
 		set.remove(adaptedElement);
 		workingSet.setElements((IAdaptable[])set.toArray(new IAdaptable[set.size()]));
 	}

 	private static void add(IWorkingSet workingSet, IAdaptable adaptedElement) {
 		IAdaptable[] elements= workingSet.getElements();
 		IAdaptable[] newElements= new IAdaptable[elements.length + 1];
 		System.arraycopy(elements, 0, newElements, 0, elements.length);
 		newElements[elements.length]= adaptedElement;
 		workingSet.setElements(newElements);
 	}

 	private void selectAndReveal(IAdaptable[] elements) {
 		PackageExplorerPart explorer= getActivePackageExplorer();
 		if (explorer != null)
 			explorer.selectReveal(new StructuredSelection(elements));
 	}

 	private PackageExplorerPart getActivePackageExplorer() {
 		IWorkbenchPage page= JavaPlugin.getActivePage();
 		if (page != null) {
 			IWorkbenchPart activePart= page.getActivePart();
 			if (activePart instanceof PackageExplorerPart) {
 				return (PackageExplorerPart) activePart;
 			}
 		}
 		return null;
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2000, 2007 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.HashSet;
	import java.util.Hashtable;
	import java.util.Iterator;
	import java.util.List;

	import org.eclipse.core.runtime.IAdaptable;

	import org.eclipse.core.resources.IResource;

	import org.eclipse.swt.SWT;
	import org.eclipse.swt.events.SelectionAdapter;
	import org.eclipse.swt.events.SelectionEvent;
	import org.eclipse.swt.layout.GridData;
	import org.eclipse.swt.layout.GridLayout;
	import org.eclipse.swt.widgets.Button;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Link;
	import org.eclipse.swt.widgets.Shell;

	import org.eclipse.jface.dialogs.IDialogConstants;
	import org.eclipse.jface.viewers.CheckStateChangedEvent;
	import org.eclipse.jface.viewers.CheckboxTableViewer;
	import org.eclipse.jface.viewers.ICheckStateListener;
	import org.eclipse.jface.viewers.IStructuredSelection;
	import org.eclipse.jface.viewers.LabelProvider;
	import org.eclipse.jface.viewers.StructuredSelection;
	import org.eclipse.jface.viewers.Viewer;
	import org.eclipse.jface.viewers.ViewerFilter;
	import org.eclipse.jface.viewers.ViewerSorter;
	import org.eclipse.jface.window.Window;

	import org.eclipse.ui.IWorkbenchPage;
	import org.eclipse.ui.IWorkbenchPart;
	import org.eclipse.ui.IWorkbenchSite;
	import org.eclipse.ui.IWorkingSet;
	import org.eclipse.ui.PlatformUI;

	import org.eclipse.jdt.core.IJavaElement;

	import org.eclipse.jdt.internal.corext.util.Messages;

	import org.eclipse.jdt.ui.JavaElementLabels;
	import org.eclipse.jdt.ui.actions.SelectionDispatchAction;

	import org.eclipse.jdt.internal.ui.JavaPlugin;
	import org.eclipse.jdt.internal.ui.packageview.PackageExplorerPart;

	public final class ConfigureWorkingSetAssignementAction extends SelectionDispatchAction {

	private static final class GrayedCheckedModel {

	private GrayedCheckedModelElement[] fElements;
	private final Hashtable fLookup;

	public GrayedCheckedModel(GrayedCheckedModelElement[] elements) {
	fElements= elements;
	fLookup= new Hashtable();
	for (int i= 0; i < elements.length; i++) {
	fLookup.put(elements[i].getWorkingSet(), elements[i]);
	}
	}

	public void addElement(GrayedCheckedModelElement element) {
	ArrayList list= new ArrayList(Arrays.asList(fElements));
	list.add(element);
	fElements= (GrayedCheckedModelElement[])list.toArray(new GrayedCheckedModelElement[list.size()]);

	fLookup.put(element.getWorkingSet(), element);
	}

	public IWorkingSet[] getAll() {
	IWorkingSet[] result= new IWorkingSet[fElements.length];
	for (int i= 0; i < fElements.length; i++) {
	result[i]= fElements[i].getWorkingSet();
	}
	return result;
	}

	public GrayedCheckedModelElement getModelElement(IWorkingSet element) {
	return (GrayedCheckedModelElement)fLookup.get(element);
	}

	public IWorkingSet[] getChecked() {
	ArrayList result= new ArrayList();
	for (int i= 0; i < fElements.length; i++) {
	if (fElements[i].isChecked())
	result.add(fElements[i].getWorkingSet());
	}
	return (IWorkingSet[])result.toArray(new IWorkingSet[result.size()]);
	}

	public IWorkingSet[] getGrayed() {
	ArrayList result= new ArrayList();
	for (int i= 0; i < fElements.length; i++) {
	if (fElements[i].isGrayed())
	result.add(fElements[i].getWorkingSet());
	}
	return (IWorkingSet[])result.toArray(new IWorkingSet[result.size()]);
	}

	public void selectAll() {
	for (int i= 0; i < fElements.length; i++) {
	fElements[i].select();
	}
	}

	public void deselectAll() {
	for (int i= 0; i < fElements.length; i++) {
	fElements[i].deselect();
	}
	}

	}

	private final static class GrayedCheckedModelElement {

	private final IWorkingSet fWorkingSet;
	private final int fElementCount;
	private int fCheckCount;

	public GrayedCheckedModelElement(IWorkingSet workingSet, int checkCount, int elementCount) {
	fWorkingSet= workingSet;
	fCheckCount= checkCount;
	fElementCount= elementCount;
	}

	public IWorkingSet getWorkingSet() {
	return fWorkingSet;
	}

	public int getCheckCount() {
	return fCheckCount;
	}

	public boolean isGrayed() {
	return isChecked() && fCheckCount < fElementCount;
	}

	public boolean isChecked() {
	return fCheckCount > 0;
	}

	public void deselect() {
	fCheckCount= 0;
	}

	public void select() {
	fCheckCount= fElementCount;
	}

	}

	private final class WorkingSetModelAwareSelectionDialog extends SimpleWorkingSetSelectionDialog {

	private CheckboxTableViewer fTableViewer;
	private boolean fShowVisibleOnly;
	private GrayedCheckedModel fModel;
	private final IAdaptable[] fElements;

	private WorkingSetModelAwareSelectionDialog(Shell shell, GrayedCheckedModel model, IAdaptable[] elements) {
	super(shell, VALID_WORKING_SET_IDS, model.getChecked());
	setTitle(WorkingSetMessages.ConfigureWorkingSetAssignementAction_WorkingSetAssignments_title);
	fModel= model;
	fShowVisibleOnly= true;
	fElements= elements;
	}

	public IWorkingSet[] getGrayed() {
	return fModel.getGrayed();
	}

	public IWorkingSet[] getSelection() {
	return fModel.getChecked();
	}

	protected CheckboxTableViewer createTableViewer(Composite parent) {
	fTableViewer= super.createTableViewer(parent);
	fTableViewer.setGrayedElements(fModel.getGrayed());
	fTableViewer.addCheckStateListener(new ICheckStateListener() {
	public void checkStateChanged(CheckStateChangedEvent event) {
	IWorkingSet element= (IWorkingSet)event.getElement();
	fTableViewer.setGrayed(element, false);
	GrayedCheckedModelElement modelElement= fModel.getModelElement(element);
	if (event.getChecked()) {
	modelElement.select();
	} else {
	modelElement.deselect();
	}
	fTableViewer.update(element, null);
	}
	});

	createShowVisibleOnly(parent);

	return fTableViewer;
	}

	protected void selectAll() {
	super.selectAll();
	fModel.selectAll();
	fTableViewer.setGrayedElements(new Object[0]);
	fTableViewer.refresh();
	}

	protected void deselectAll() {
	super.deselectAll();
	fModel.deselectAll();
	fTableViewer.setGrayedElements(new Object[0]);
	fTableViewer.refresh();
	}

	/**
	* {@inheritDoc}
	*/
	protected void addNewWorkingSet(IWorkingSet workingSet) {
	if (fWorkingSetModel != null) {
	IWorkingSet[] workingSets= fWorkingSetModel.getActiveWorkingSets();
	IWorkingSet[] activeWorkingSets= new IWorkingSet[workingSets.length+ 1];
	activeWorkingSets[0]= workingSet;
	System.arraycopy(workingSets, 0, activeWorkingSets, 1, workingSets.length);
	fWorkingSetModel.setActiveWorkingSets(activeWorkingSets);
	}

	int checkCount= 0;
	for (int i= 0; i < fElements.length; i++) {
	IAdaptable adapted= adapt(workingSet, fElements[i]);
	if (adapted != null && contains(workingSet, adapted)) {
	checkCount++;
	}
	}

	fModel.addElement(new GrayedCheckedModelElement(workingSet, checkCount, fElements.length));

	fTableViewer.setInput(fModel.getAll());
	fTableViewer.refresh();

	fTableViewer.setCheckedElements(fModel.getChecked());
	fTableViewer.setGrayedElements(fModel.getGrayed());

	fTableViewer.setSelection(new StructuredSelection(workingSet));
	}

	protected ViewerFilter createTableFilter() {
	final ViewerFilter superFilter= super.createTableFilter();
	return new ViewerFilter() {
	public boolean select(Viewer viewer, Object parentElement, Object element) {
	if (!superFilter.select(viewer, parentElement, element))
	return false;

	IWorkingSet set= (IWorkingSet)element;
	if (!isValidWorkingSet(set))
	return false;

	if (fWorkingSetModel == null)
	return true;

	if (fShowVisibleOnly) {
	if (!fWorkingSetModel.isActiveWorkingSet(set))
	return false;

	return true;
	} else {
	return true;
	}
	}
	};
	}

	protected ViewerSorter createTableSorter() {
	final ViewerSorter superSorter= super.createTableSorter();
	return new ViewerSorter() {
	public int compare(Viewer viewer, Object e1, Object e2) {
	if (fWorkingSetModel == null)
	return superSorter.compare(viewer, e1, e2);

	IWorkingSet[] activeWorkingSets= fWorkingSetModel.getActiveWorkingSets();
	for (int i= 0; i < activeWorkingSets.length; i++) {
	IWorkingSet active= activeWorkingSets[i];
	if (active == e1) {
	return -1;
	} else if (active == e2) {
	return 1;
	}
	}

	return superSorter.compare(viewer, e1, e2);
	}
	};
	}

	protected LabelProvider createTableLabelProvider() {
	final LabelProvider superLabelProvider= super.createTableLabelProvider();
	return new LabelProvider() {
	public String getText(Object element) {
	String superText= superLabelProvider.getText(element);
	if (superText == null)
	return null;

	GrayedCheckedModelElement modelElement= fModel.getModelElement((IWorkingSet)element);
	if (!modelElement.isGrayed())
	return superText;

	return superText + Messages.format(WorkingSetMessages.ConfigureWorkingSetAssignementAction_XofY_label, new Object[] {new Integer(modelElement.getCheckCount()), new Integer(fElements.length)});
	}
	};
	}

	private void createShowVisibleOnly(Composite parent) {
	if (fWorkingSetModel == null)
	return;

	Composite bar= new Composite(parent, SWT.NONE);
	bar.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
	GridLayout gridLayout= new GridLayout(2, false);
	gridLayout.marginHeight= 0;
	gridLayout.marginWidth= 0;
	bar.setLayout(gridLayout);

	final Button showVisibleOnly= new Button(bar, SWT.CHECK);
	showVisibleOnly.setSelection(fShowVisibleOnly);
	showVisibleOnly.setLayoutData(new GridData(SWT.LEAD, SWT.FILL, false, true));
	showVisibleOnly.addSelectionListener(new SelectionAdapter() {
	public void widgetSelected(SelectionEvent e) {
	fShowVisibleOnly= showVisibleOnly.getSelection();

	fTableViewer.refresh();

	fTableViewer.setCheckedElements(fModel.getChecked());
	fTableViewer.setGrayedElements(fModel.getGrayed());
	}
	});

	Link ppwsLink= new Link(bar, SWT.NONE);
	ppwsLink.setText(WorkingSetMessages.ConfigureWorkingSetAssignementAction_OnlyShowVisible_link);
	ppwsLink.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
	ppwsLink.addSelectionListener(new SelectionAdapter() {
	public void widgetSelected(SelectionEvent e) {

	List workingSets= new ArrayList(Arrays.asList(fWorkingSetModel.getAllWorkingSets()));
	IWorkingSet[] activeWorkingSets= fWorkingSetModel.getActiveWorkingSets();
	WorkingSetConfigurationDialog dialog= new WorkingSetConfigurationDialog(
	getShell(),
	(IWorkingSet[])workingSets.toArray(new IWorkingSet[workingSets.size()]),
	activeWorkingSets);
	dialog.setSelection(activeWorkingSets);
	if (dialog.open() == IDialogConstants.OK_ID) {
	IWorkingSet[] selection= dialog.getSelection();
	fWorkingSetModel.setActiveWorkingSets(selection);
	}

	recalculateCheckedState();
	}
	});
	}

	private void recalculateCheckedState() {
	fModel= createGrayedCheckedModel(fElements, getAllWorkingSets());

	fTableViewer.setInput(fModel.getAll());
	fTableViewer.refresh();
	fTableViewer.setCheckedElements(fModel.getChecked());
	fTableViewer.setGrayedElements(fModel.getGrayed());
	}
	}

	private static final String[] VALID_WORKING_SET_IDS= new String[] {
	JavaWorkingSetUpdater.ID,
	"org.eclipse.ui.resourceWorkingSetPage" //$NON-NLS-1$
	};

	private WorkingSetModel fWorkingSetModel;
	private final IWorkbenchSite fSite;

	public ConfigureWorkingSetAssignementAction(IWorkbenchSite site) {
	super(site);
	fSite= site;
	setText(WorkingSetMessages.ConfigureWorkingSetAssignementAction_WorkingSets_actionLabel);
	setEnabled(false);
	}

	public void setWorkingSetModel(WorkingSetModel workingSetModel) {
	fWorkingSetModel= workingSetModel;
	}

	public void selectionChanged(IStructuredSelection selection) {
	setEnabled(canEnable(selection));
	}

	private boolean canEnable(IStructuredSelection selection) {
	if (selection.isEmpty())
	return false;

	List list= selection.toList();
	for (Iterator iterator= list.iterator(); iterator.hasNext();) {
	Object object= iterator.next();
	if (!(object instanceof IResource) && !(object instanceof IJavaElement))
	return false;
	}

	return true;
	}

	private IAdaptable[] getSelectedElements(IStructuredSelection selection) {
	ArrayList result= new ArrayList();

	List list= selection.toList();
	for (Iterator iterator= list.iterator(); iterator.hasNext();) {
	Object object= iterator.next();
	if (object instanceof IResource \|\| object instanceof IJavaElement) {
	result.add(object);
	}
	}

	return (IAdaptable[])result.toArray(new IAdaptable[result.size()]);
	}

	public void run(IStructuredSelection selection) {
	IAdaptable[] elements= getSelectedElements(selection);
	GrayedCheckedModel model= createGrayedCheckedModel(elements, getAllWorkingSets());
	WorkingSetModelAwareSelectionDialog dialog= new WorkingSetModelAwareSelectionDialog(fSite.getShell(), model, elements);

	if (elements.length == 1) {
	IAdaptable element= elements[0];
	String elementName;
	if (element instanceof IResource) {
	elementName= ((IResource)element).getName();
	} else {
	elementName= JavaElementLabels.getElementLabel((IJavaElement)element, JavaElementLabels.ALL_DEFAULT);
	}
	dialog.setMessage(Messages.format(WorkingSetMessages.ConfigureWorkingSetAssignementAction_DialogMessage_specific, elementName));
	} else {
	dialog.setMessage(Messages.format(WorkingSetMessages.ConfigureWorkingSetAssignementAction_DialogMessage_multi, new Integer(elements.length)));
	}
	if (dialog.open() == Window.OK) {
	updateWorkingSets(dialog.getSelection(), dialog.getGrayed(), elements);
	selectAndReveal(elements);
	}
	}

	private static GrayedCheckedModel createGrayedCheckedModel(IAdaptable[] elements, IWorkingSet[] workingSets) {
	GrayedCheckedModelElement[] result= new GrayedCheckedModelElement[workingSets.length];

	for (int i= 0; i < workingSets.length; i++) {
	IWorkingSet set= workingSets[i];

	int checkCount= 0;
	for (int j= 0; j < elements.length; j++) {
	IAdaptable adapted= adapt(set, elements[j]);
	if (adapted != null && contains(set, adapted)) {
	checkCount++;
	}
	}

	result[i]= new GrayedCheckedModelElement(set, checkCount, elements.length);
	}

	return new GrayedCheckedModel(result);
	}

	private void updateWorkingSets(IWorkingSet[] newWorkingSets, IWorkingSet[] grayedWorkingSets, IAdaptable[] elements) {
	HashSet selectedSets= new HashSet(Arrays.asList(newWorkingSets));
	HashSet grayedSets= new HashSet(Arrays.asList(grayedWorkingSets));
	IWorkingSet[] workingSets= getAllWorkingSets();

	for (int i= 0; i < workingSets.length; i++) {
	IWorkingSet workingSet= workingSets[i];
	if (isValidWorkingSet(workingSet) && !selectedSets.contains(workingSet) && !grayedSets.contains(workingSet)) {
	for (int j= 0; j < elements.length; j++) {
	IAdaptable adapted= adapt(workingSet, elements[j]);
	if (adapted != null && contains(workingSet, adapted)) {
	remove(workingSet, adapted);
	}
	}
	}
	}

	for (int i= 0; i < newWorkingSets.length; i++) {
	IWorkingSet set= newWorkingSets[i];
	if (isValidWorkingSet(set) && !grayedSets.contains(set)) {
	for (int j= 0; j < elements.length; j++) {
	IAdaptable adapted= adapt(set, elements[j]);
	if (adapted != null && !contains(set, adapted)) {
	add(set, adapted);
	}
	}
	}
	}
	}

	private IWorkingSet[] getAllWorkingSets() {
	if (fWorkingSetModel != null) {
	return fWorkingSetModel.getAllWorkingSets();
	} else {
	return PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSets();
	}
	}

	private static boolean isValidWorkingSet(IWorkingSet set) {
	if (set.isAggregateWorkingSet() \|\| !set.isSelfUpdating())
	return false;

	if (!set.isVisible())
	return false;

	if (!set.isEditable())
	return false;

	for (int i= 0; i < VALID_WORKING_SET_IDS.length; i++) {
	if (VALID_WORKING_SET_IDS[i].equals(set.getId()))
	return true;
	}

	return false;
	}

	private static IAdaptable adapt(IWorkingSet set, IAdaptable element) {
	IAdaptable[] adaptedElements= set.adaptElements(new IAdaptable[] {
	element
	});
	if (adaptedElements.length != 1)
	return null;

	return adaptedElements[0];
	}

	private static boolean contains(IWorkingSet set, IAdaptable adaptedElement) {
	IAdaptable[] elements= set.getElements();
	for (int i= 0; i < elements.length; i++) {
	if (elements[i].equals(adaptedElement))
	return true;
	}

	return false;
	}

	private static void remove(IWorkingSet workingSet, IAdaptable adaptedElement) {
	HashSet set= new HashSet(Arrays.asList(workingSet.getElements()));
	set.remove(adaptedElement);
	workingSet.setElements((IAdaptable[])set.toArray(new IAdaptable[set.size()]));
	}

	private static void add(IWorkingSet workingSet, IAdaptable adaptedElement) {
	IAdaptable[] elements= workingSet.getElements();
	IAdaptable[] newElements= new IAdaptable[elements.length + 1];
	System.arraycopy(elements, 0, newElements, 0, elements.length);
	newElements[elements.length]= adaptedElement;
	workingSet.setElements(newElements);
	}

	private void selectAndReveal(IAdaptable[] elements) {
	PackageExplorerPart explorer= getActivePackageExplorer();
	if (explorer != null)
	explorer.selectReveal(new StructuredSelection(elements));
	}

	private PackageExplorerPart getActivePackageExplorer() {
	IWorkbenchPage page= JavaPlugin.getActivePage();
	if (page != null) {
	IWorkbenchPart activePart= page.getActivePart();
	if (activePart instanceof PackageExplorerPart) {
	return (PackageExplorerPart) activePart;
	}
	}
	return null;
	}

	}