public static String WorkingSetConfigurationDialog_title;

	public static String WorkingSetConfigurationDialog_message;

	public static String WorkingSetConfigurationDialog_new_label;

	public static String WorkingSetConfigurationDialog_edit_label;

	public static String WorkingSetConfigurationDialog_remove_label;

	public static String WorkingSetConfigurationDialog_up_label;

	public static String WorkingSetConfigurationDialog_down_label;

	public static String WorkingSetConfigurationDialog_selectAll_label;

	public static String WorkingSetConfigurationDialog_deselectAll_label;

	public static String WorkingSetConfigurationDialog_sort_working_sets;

/*******************************************************************************

 * Copyright (c) 2000, 2010 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

 * 		Sebastian Davids <sdavids@gmx.de> - Fix for bug 19346 - Dialog font

 *   	should be activated and used by other components.

 *******************************************************************************/

package org.eclipse.ui.internal.dialogs;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.eclipse.jface.dialogs.IDialogConstants;

import org.eclipse.jface.viewers.CheckStateChangedEvent;

import org.eclipse.jface.viewers.CheckboxTableViewer;

import org.eclipse.jface.viewers.DoubleClickEvent;

import org.eclipse.jface.viewers.ICheckStateListener;

import org.eclipse.jface.viewers.IDoubleClickListener;

import org.eclipse.jface.viewers.ILabelProvider;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredContentProvider;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerComparator;

import org.eclipse.jface.viewers.ViewerFilter;

import org.eclipse.jface.window.Window;

import org.eclipse.jface.wizard.WizardDialog;

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.Control;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.IWorkingSet;

import org.eclipse.ui.IWorkingSetManager;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.dialogs.IWorkingSetEditWizard;

import org.eclipse.ui.dialogs.IWorkingSetNewWizard;

import org.eclipse.ui.dialogs.SelectionDialog;

import org.eclipse.ui.internal.WorkbenchMessages;

import org.eclipse.ui.internal.WorkingSetComparator;

public class WorkingSetConfigurationDialog extends SelectionDialog {

	private List fAllWorkingSets;

	private CheckboxTableViewer fTableViewer;

	private Button fNewButton;

	private Button fEditButton;

	private Button fRemoveButton;

	private Button fUpButton;

	private Button fDownButton;

	private Button fSelectAll;

	private Button fDeselectAll;

	/**

	 * Sort working sets button.

	 * 

	 * @since 3.5

	 */

	private Button fSortWorkingSet;

	private IWorkingSet[] fResult;

	private List fAddedWorkingSets;

	private List fRemovedWorkingSets;

	private Map fEditedWorkingSets;

	private List fRemovedMRUWorkingSets;

	private String[] fNewWorkingSets;

	private ILabelProvider fLabelProvider;

	private ViewerFilter fFilter;

	private String fHelpContext;

	private int nextButtonId= IDialogConstants.CLIENT_ID + 1;

	/**

	 * Value of sorted state of working sets.

	 * 

	 * @since 3.5

	 */

	private boolean fIsSortingEnabled;

	/**

	 * The working set comparator.

	 * 

	 * @since 3.5

	 */

	private Comparator fComparator;

	public WorkingSetConfigurationDialog(Shell parentShell, IWorkingSet[] allWorkingSets,

			String[] newWorkingSets, ILabelProvider labelProvider, ViewerFilter filter,

			String helpContext, boolean isSortingEnabled) {

		super(parentShell);

		setTitle(WorkbenchMessages.WorkingSetConfigurationDialog_title);

		setMessage(WorkbenchMessages.WorkingSetConfigurationDialog_message);

		fNewWorkingSets = newWorkingSets;

		fAllWorkingSets= new ArrayList(allWorkingSets.length);

		fFilter = filter;

		for (int i= 0; i < allWorkingSets.length; i++) {

			if (fFilter.select(null, null, allWorkingSets[i]))

				fAllWorkingSets.add(allWorkingSets[i]);

		}

		fLabelProvider = labelProvider;

		fHelpContext = helpContext;

		fIsSortingEnabled= isSortingEnabled;

	}

	/**

	 * {@inheritDoc}

	 */

	protected void configureShell(Shell shell) {

		super.configureShell(shell);

		PlatformUI.getWorkbench().getHelpSystem().setHelp(shell, fHelpContext);

	}

	/**

	 * Returns the selected working sets

	 *

	 * @return the selected working sets

	 */

	public IWorkingSet[] getSelection() {

		return fResult;

	}

	/**

	 * Sets the initial selection

	 *

	 * @param workingSets the initial selection

	 */

	public void setSelection(IWorkingSet[] workingSets) {

		fResult= workingSets;

		setInitialSelections(workingSets);

	}

	/**

	 * {@inheritDoc}

	 */

	protected Control createContents(Composite parent) {

		Control control= super.createContents(parent);

		setInitialSelection();

		updateButtonAvailability();

		return control;

	}

	/**

	 * {@inheritDoc}

	 */

	protected Control createDialogArea(Composite parent) {

		Composite composite= (Composite)super.createDialogArea(parent);

		createMessageArea(composite);

		Composite inner= new Composite(composite, SWT.NONE);

		inner.setLayoutData(new GridData(GridData.FILL_BOTH));

		GridLayout layout= new GridLayout();

		layout.numColumns= 2;

		layout.marginHeight= 0;

		layout.marginWidth= 0;

		inner.setLayout(layout);

		createTableViewer(inner);

		createOrderButtons(inner);

		createModifyButtons(composite);

		if (fIsSortingEnabled) {

			fTableViewer.setComparator(new ViewerComparator(getComparator()) {

				/*

				 * @see ViewerComparator#compare(Viewer, Object, Object)

				 * @since 3.5

				 */

				public int compare(Viewer viewer, Object e1, Object e2) {

					return getComparator().compare(e1, e2);

				}

			});

		}

		fTableViewer.setInput(fAllWorkingSets);

		applyDialogFont(composite);

		return composite;

	}

	private void createTableViewer(Composite parent) {

		fTableViewer= CheckboxTableViewer.newCheckList(parent, SWT.BORDER | SWT.MULTI);

		fTableViewer.addCheckStateListener(new ICheckStateListener() {

			public void checkStateChanged(CheckStateChangedEvent event) {

				updateButtonAvailability();

			}

		});

		GridData data= new GridData(GridData.FILL_BOTH);

		data.heightHint= convertHeightInCharsToPixels(20);

		data.widthHint= convertWidthInCharsToPixels(50);

		fTableViewer.getTable().setLayoutData(data);

		fTableViewer.addFilter(fFilter);

		fTableViewer.setLabelProvider(fLabelProvider);

		fTableViewer.setContentProvider(new IStructuredContentProvider() {

			public Object[] getElements(Object element) {

				return ((List)element).toArray();

			}

			public void dispose() {

			}

			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

			}

		});

		fTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {

			public void selectionChanged(SelectionChangedEvent event) {

				handleSelectionChanged();

			}

		});

		fTableViewer.addDoubleClickListener(new IDoubleClickListener() {

			public void doubleClick(DoubleClickEvent event) {

				if (fEditButton.isEnabled())

					editSelectedWorkingSet();

			}

		});

	}

	private void createModifyButtons(Composite composite) {

		Composite buttonComposite= new Composite(composite, SWT.RIGHT);

		GridLayout layout= new GridLayout();

		layout.numColumns= 2;

		buttonComposite.setLayout(layout);

		GridData data= new GridData(GridData.HORIZONTAL_ALIGN_END | GridData.GRAB_HORIZONTAL);

		data.grabExcessHorizontalSpace= true;

		composite.setData(data);

		fNewButton= createButton(buttonComposite, nextButtonId++,

				WorkbenchMessages.WorkingSetConfigurationDialog_new_label, false);

		fNewButton.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				createWorkingSet();

			}

		});

		fEditButton= createButton(buttonComposite, nextButtonId++,

				WorkbenchMessages.WorkingSetConfigurationDialog_edit_label, false);

		fEditButton.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				editSelectedWorkingSet();

			}

		});

		fRemoveButton= createButton(buttonComposite, nextButtonId++,

				WorkbenchMessages.WorkingSetConfigurationDialog_remove_label, false);

		fRemoveButton.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				removeSelectedWorkingSets();

			}

		});

	}

	private void createOrderButtons(Composite parent) {

		Composite buttons= new Composite(parent, SWT.NONE);

		buttons.setLayoutData(new GridData(GridData.FILL_VERTICAL));

		GridLayout layout= new GridLayout();

		layout.marginHeight= 0;

		layout.marginWidth= 0;

		buttons.setLayout(layout);

		fUpButton= new Button(buttons, SWT.PUSH);

		fUpButton.setText(WorkbenchMessages.WorkingSetConfigurationDialog_up_label);

		setButtonLayoutData(fUpButton);

		fUpButton.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				moveUp(((IStructuredSelection)fTableViewer.getSelection()).toList());

			}

		});

		fDownButton= new Button(buttons, SWT.PUSH);

		fDownButton.setText(WorkbenchMessages.WorkingSetConfigurationDialog_down_label);

		setButtonLayoutData(fDownButton);

		fDownButton.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				moveDown(((IStructuredSelection)fTableViewer.getSelection()).toList());

			}

		});

		fSelectAll= new Button(buttons, SWT.PUSH);

		fSelectAll.setText(WorkbenchMessages.WorkingSetConfigurationDialog_selectAll_label);

		setButtonLayoutData(fSelectAll);

		fSelectAll.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				selectAll();

			}

		});

		fDeselectAll= new Button(buttons, SWT.PUSH);

		fDeselectAll.setText(WorkbenchMessages.WorkingSetConfigurationDialog_deselectAll_label);

		setButtonLayoutData(fDeselectAll);

		fDeselectAll.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				deselectAll();

			}

		});

		/**

		 * A check box that has persistence to sort the working sets alphabetically in the

		 * WorkingSetConfigurationDialog. It restores the unsorted order of the working sets when

		 * unchecked.

		 * 

		 * @since 3.5

		 */

		fSortWorkingSet= new Button(parent, SWT.CHECK);

		fSortWorkingSet.setText(WorkbenchMessages.WorkingSetConfigurationDialog_sort_working_sets);

		fSortWorkingSet.setLayoutData(new GridData(SWT.LEAD, SWT.CENTER, true, false));

		fSortWorkingSet.setSelection(fIsSortingEnabled);

		fSortWorkingSet.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				fIsSortingEnabled= fSortWorkingSet.getSelection();

				updateButtonAvailability();

				if (fIsSortingEnabled) {

					fTableViewer.setComparator(new ViewerComparator(getComparator()) {

						/*

						 * @see ViewerComparator#compare(Viewer, Object, Object)

						 * @since 3.5

						 */

						public int compare(Viewer viewer, Object e1, Object e2) {

							return getComparator().compare(e1, e2);

						}

					});

				} else {

					fTableViewer.setComparator(null);

				}

			}

		});

	}

	/**

	 * {@inheritDoc}

	 */

	protected void okPressed() {

		List newResult= getResultWorkingSets();

		fResult= (IWorkingSet[])newResult.toArray(new IWorkingSet[newResult.size()]);

		setResult(newResult);

		super.okPressed();

	}

	private List getResultWorkingSets() {

		Object[] checked= fTableViewer.getCheckedElements();

		return new ArrayList(Arrays.asList(checked));

	}

	/**

	 * {@inheritDoc}

	 */

	protected void cancelPressed() {

		restoreAddedWorkingSets();

		restoreChangedWorkingSets();

		restoreRemovedWorkingSets();

		super.cancelPressed();

	}

	private void setInitialSelection() {

		List selections= getInitialElementSelections();

		if (!selections.isEmpty()) {

			fTableViewer.setCheckedElements(selections.toArray());

		}

	}

	private void createWorkingSet() {

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

		IWorkingSetNewWizard wizard = manager.createWorkingSetNewWizard(fNewWorkingSets);

		// 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 (fFilter.select(null, null, workingSet)) {

				fAllWorkingSets.add(workingSet);

				fTableViewer.add(workingSet);

				fTableViewer.setSelection(new StructuredSelection(workingSet), true);

				fTableViewer.setChecked(workingSet, true);

				manager.addWorkingSet(workingSet);

				fAddedWorkingSets.add(workingSet);

			}

		}

	}

	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= (IWorkingSet)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);

	}

	/**

	 * Called when the selection has changed.

	 */

	void handleSelectionChanged() {

		updateButtonAvailability();

	}

	/**

	 * Overrides method in Dialog

	 *

	 * @see org.eclipse.jface.dialogs.Dialog#open()

	 */

	public int open() {

		fAddedWorkingSets= new ArrayList();

		fRemovedWorkingSets= new ArrayList();

		fEditedWorkingSets= new HashMap();

		fRemovedMRUWorkingSets= new ArrayList();

		return super.open();

	}

	/**

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

		}

	}

	/**

	 * Removes newly created working sets from the working set manager.

	 */

	private void restoreAddedWorkingSets() {

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

		Iterator iterator= fAddedWorkingSets.iterator();

		while (iterator.hasNext()) {

			manager.removeWorkingSet(((IWorkingSet)iterator.next()));

		}

	}

	/**

	 * Rolls back changes to working sets.

	 */

	private void restoreChangedWorkingSets() {

		Iterator iterator= fEditedWorkingSets.keySet().iterator();

		while (iterator.hasNext()) {

			IWorkingSet editedWorkingSet= (IWorkingSet)iterator.next();

			IWorkingSet originalWorkingSet= (IWorkingSet)fEditedWorkingSets.get(editedWorkingSet);

			if (editedWorkingSet.getName().equals(originalWorkingSet.getName()) == false) {

				editedWorkingSet.setName(originalWorkingSet.getName());

			}

			if (editedWorkingSet.getElements().equals(originalWorkingSet.getElements()) == false) {

				editedWorkingSet.setElements(originalWorkingSet.getElements());

			}

		}

	}

	/**

	 * Adds back removed working sets to the working set manager.

	 */

	private void restoreRemovedWorkingSets() {

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

		Iterator iterator= fRemovedWorkingSets.iterator();

		while (iterator.hasNext()) {

			manager.addWorkingSet(((IWorkingSet)iterator.next()));

		}

		iterator= fRemovedMRUWorkingSets.iterator();

		while (iterator.hasNext()) {

			manager.addRecentWorkingSet(((IWorkingSet)iterator.next()));

		}

	}

	/**

	 * Updates the modify buttons' enabled state based on the current seleciton.

	 */

	private void updateButtonAvailability() {

		IStructuredSelection selection= (IStructuredSelection) fTableViewer.getSelection();

		boolean hasSelection= !selection.isEmpty();

		boolean hasSingleSelection= selection.size() == 1;

		fRemoveButton.setEnabled(hasSelection && areAllGlobalWorkingSets(selection));

		fEditButton.setEnabled(hasSingleSelection && ((IWorkingSet)selection.getFirstElement()).isEditable());

		if (fUpButton != null) {

			fUpButton.setEnabled(canMoveUp());

		}

		if (fDownButton != null) {

			fDownButton.setEnabled(canMoveDown());

		}

	}

	private boolean areAllGlobalWorkingSets(IStructuredSelection selection) {

		Set globals= new HashSet(Arrays.asList(PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSets()));

		for (Iterator iter= selection.iterator(); iter.hasNext();) {

			if (!globals.contains(iter.next()))

				return false;

		}

		return true;

	}

	private void moveUp(List toMoveUp) {

		if (toMoveUp.size() > 0) {

			setElements(moveUp(fAllWorkingSets, toMoveUp));

			fTableViewer.reveal(toMoveUp.get(0));

		}

	}

	private void moveDown(List toMoveDown) {

		if (toMoveDown.size() > 0) {

			setElements(reverse(moveUp(reverse(fAllWorkingSets), toMoveDown)));

			fTableViewer.reveal(toMoveDown.get(toMoveDown.size() - 1));

		}

	}

	private void setElements(List elements) {

		fAllWorkingSets= elements;

		fTableViewer.setInput(fAllWorkingSets);

		updateButtonAvailability();

	}

	private List moveUp(List elements, List move) {

		int nElements= elements.size();

		List res= new ArrayList(nElements);

		Object floating= null;

		for (int i= 0; i < nElements; i++) {

			Object curr= elements.get(i);

			if (move.contains(curr)) {

				res.add(curr);

			} else {

				if (floating != null) {

					res.add(floating);

				}

				floating= curr;

			}

		}

		if (floating != null) {

			res.add(floating);

		}

		return res;

	}

	private List reverse(List p) {

		List reverse= new ArrayList(p.size());

		for (int i= p.size() - 1; i >= 0; i--) {

			reverse.add(p.get(i));

		}

		return reverse;

	}

	private boolean canMoveUp() {

		if (!fIsSortingEnabled) {

			int[] indc= fTableViewer.getTable().getSelectionIndices();

			for (int i= 0; i < indc.length; i++) {

				if (indc[i] != i) {

					return true;

				}

			}

		}

		return false;

	}

	private boolean canMoveDown() {

		if (!fIsSortingEnabled) {

			int[] indc= fTableViewer.getTable().getSelectionIndices();

			int k= fAllWorkingSets.size() - 1;

			for (int i= indc.length - 1; i >= 0; i--, k--) {

				if (indc[i] != k) {

					return true;

				}

			}

		}

		return false;

	}

	//---- select / deselect --------------------------------------------------

	private void selectAll() {

		fTableViewer.setAllChecked(true);

	}

	private void deselectAll() {

		fTableViewer.setAllChecked(false);

	}

	/**

	 * Returns the list of newly added working sets through this dialog.

	 * 

	 * @return the list of newly added working sets

	 * @since 3.5

	 */

	public List getNewlyAddedWorkingSets() {

		return fAddedWorkingSets;

	}

	/**

	 * 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;

	}

	/**

	 * Returns the working set comparator.

	 * 

	 * @return the working set comparator

	 * @since 3.5

	 */

	private Comparator getComparator() {

		if (fComparator == null) {

			fComparator = new WorkingSetComparator();

		}

		return fComparator;

	}

}

#---- working set configuration dialog ------------------------------------------------

WorkingSetConfigurationDialog_title=Configure Working Sets

WorkingSetConfigurationDialog_message=Select and sort &working sets visible in Package Explorer:

WorkingSetConfigurationDialog_new_label=&New...

WorkingSetConfigurationDialog_edit_label=&Edit...

WorkingSetConfigurationDialog_remove_label=&Remove

WorkingSetConfigurationDialog_up_label=&Up

WorkingSetConfigurationDialog_down_label=&Down

WorkingSetConfigurationDialog_selectAll_label=Select &All

WorkingSetConfigurationDialog_deselectAll_label=Dese&lect All

WorkingSetConfigurationDialog_sort_working_sets=&Sort working sets