/*******************************************************************************
* Copyright (c) 2000, 2011 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Sebastian Davids <sdavids@gmx.de> - Fix for bug 19346 - Dialog font
* should be activated and used by other components.
*******************************************************************************/
package org.eclipse.jdt.internal.ui.workingsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
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.core.runtime.Assert;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ArrayContentProvider;
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.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
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.window.Window;
import org.eclipse.jface.wizard.WizardDialog;
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.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.viewsupport.BasicElementLabels;
public class WorkingSetConfigurationDialog extends SelectionDialog {
private static class WorkingSetLabelProvider extends LabelProvider {
private Map<ImageDescriptor, Image> fIcons;
public WorkingSetLabelProvider() {
fIcons= new Hashtable<ImageDescriptor, Image>();
}
@Override
public void dispose() {
Iterator<Image> iterator= fIcons.values().iterator();
while (iterator.hasNext()) {
Image icon= iterator.next();
icon.dispose();
}
super.dispose();
}
@Override
public Image getImage(Object object) {
Assert.isTrue(object instanceof IWorkingSet);
IWorkingSet workingSet= (IWorkingSet)object;
ImageDescriptor imageDescriptor= workingSet.getImageDescriptor();
if (imageDescriptor == null)
return null;
Image icon= fIcons.get(imageDescriptor);
if (icon == null) {
icon= imageDescriptor.createImage();
fIcons.put(imageDescriptor, icon);
}
return icon;
}
@Override
public String getText(Object object) {
Assert.isTrue(object instanceof IWorkingSet);
IWorkingSet workingSet= (IWorkingSet)object;
return BasicElementLabels.getWorkingSetLabel(workingSet);
}
}
private List<IWorkingSet> 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<IWorkingSet> fAddedWorkingSets;
private List<IWorkingSet> fRemovedWorkingSets;
private Map<IWorkingSet, IWorkingSet> fEditedWorkingSets;
private List<IWorkingSet> fRemovedMRUWorkingSets;
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 WorkingSetComparator fComparator;
public WorkingSetConfigurationDialog(Shell parentShell, IWorkingSet[] allWorkingSets, boolean isSortingEnabled) {
super(parentShell);
setTitle(WorkingSetMessages.WorkingSetConfigurationDialog_title);
setMessage(WorkingSetMessages.WorkingSetConfigurationDialog_message);
fAllWorkingSets= new ArrayList<IWorkingSet>(allWorkingSets.length);
for (int i= 0; i < allWorkingSets.length; i++) {
fAllWorkingSets.add(allWorkingSets[i]);
}
fIsSortingEnabled= isSortingEnabled;
}
/**
* {@inheritDoc}
*/
@Override
protected void configureShell(Shell shell) {
super.configureShell(shell);
PlatformUI.getWorkbench().getHelpSystem().setHelp(shell, IJavaHelpContextIds.WORKING_SET_CONFIGURATION_DIALOG);
}
/**
* 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}
*/
@Override
protected Control createContents(Composite parent) {
Control control= super.createContents(parent);
setInitialSelection();
updateButtonAvailability();
return control;
}
/**
* {@inheritDoc}
*/
@Override
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
*/
@Override
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.setLabelProvider(new WorkingSetLabelProvider());
fTableViewer.setContentProvider(new ArrayContentProvider());
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++,
WorkingSetMessages.WorkingSetConfigurationDialog_new_label, false);
fNewButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
createWorkingSet();
}
});
fEditButton= createButton(buttonComposite, nextButtonId++,
WorkingSetMessages.WorkingSetConfigurationDialog_edit_label, false);
fEditButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
editSelectedWorkingSet();
}
});
fRemoveButton= createButton(buttonComposite, nextButtonId++,
WorkingSetMessages.WorkingSetConfigurationDialog_remove_label, false);
fRemoveButton.addSelectionListener(new SelectionAdapter() {
@Override
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(WorkingSetMessages.WorkingSetConfigurationDialog_up_label);
setButtonLayoutData(fUpButton);
fUpButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
moveUp(((IStructuredSelection)fTableViewer.getSelection()).toList());
}
});
fDownButton= new Button(buttons, SWT.PUSH);
fDownButton.setText(WorkingSetMessages.WorkingSetConfigurationDialog_down_label);
setButtonLayoutData(fDownButton);
fDownButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
moveDown(((IStructuredSelection)fTableViewer.getSelection()).toList());
}
});
fSelectAll= new Button(buttons, SWT.PUSH);
fSelectAll.setText(WorkingSetMessages.WorkingSetConfigurationDialog_selectAll_label);
setButtonLayoutData(fSelectAll);
fSelectAll.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
selectAll();
}
});
fDeselectAll= new Button(buttons, SWT.PUSH);
fDeselectAll.setText(WorkingSetMessages.WorkingSetConfigurationDialog_deselectAll_label);
setButtonLayoutData(fDeselectAll);
fDeselectAll.addSelectionListener(new SelectionAdapter() {
@Override
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(WorkingSetMessages.WorkingSetConfigurationDialog_sort_working_sets);
fSortWorkingSet.setLayoutData(new GridData(SWT.LEAD, SWT.CENTER, true, false));
fSortWorkingSet.setSelection(fIsSortingEnabled);
fSortWorkingSet.addSelectionListener(new SelectionAdapter() {
@Override
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
*/
@Override
public int compare(Viewer viewer, Object e1, Object e2) {
return getComparator().compare(e1, e2);
}
});
} else {
fTableViewer.setComparator(null);
}
}
});
}
/**
* {@inheritDoc}
*/
@Override
protected void okPressed() {
List<IWorkingSet> newResult= getResultWorkingSets();
fResult= newResult.toArray(new IWorkingSet[newResult.size()]);
if (fIsSortingEnabled) {
Collections.sort(fAllWorkingSets, getComparator());
}
setResult(newResult);
super.okPressed();
}
@SuppressWarnings({ "unchecked", "rawtypes" })
private List<IWorkingSet> getResultWorkingSets() {
Object[] checked= fTableViewer.getCheckedElements();
return new ArrayList(Arrays.asList(checked));
}
/**
* {@inheritDoc}
*/
@Override
protected void cancelPressed() {
restoreAddedWorkingSets();
restoreChangedWorkingSets();
restoreRemovedWorkingSets();
super.cancelPressed();
}
private void setInitialSelection() {
List<Object[]> selections= getInitialElementSelections();
if (!selections.isEmpty()) {
fTableViewer.setCheckedElements(selections.toArray());
}
}
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);
}
}
}
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);
}
/**
* Called when the selection has changed.
*/
void handleSelectionChanged() {
updateButtonAvailability();
}
/**
* Overrides method in Dialog
*
* @see org.eclipse.jface.dialogs.Dialog#open()
*/
@Override
public int open() {
fAddedWorkingSets= new ArrayList<IWorkingSet>();
fRemovedWorkingSets= new ArrayList<IWorkingSet>();
fEditedWorkingSets= new HashMap<IWorkingSet, IWorkingSet>();
fRemovedMRUWorkingSets= new ArrayList<IWorkingSet>();
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<IWorkingSet> iterator= fAddedWorkingSets.iterator();
while (iterator.hasNext()) {
manager.removeWorkingSet(iterator.next());
}
}
/**
* Rolls back changes to working sets.
*/
private void restoreChangedWorkingSets() {
Iterator<IWorkingSet> iterator= fEditedWorkingSets.keySet().iterator();
while (iterator.hasNext()) {
IWorkingSet editedWorkingSet= iterator.next();
IWorkingSet originalWorkingSet= 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<IWorkingSet> iterator= fRemovedWorkingSets.iterator();
while (iterator.hasNext()) {
manager.addWorkingSet(iterator.next());
}
iterator= fRemovedMRUWorkingSets.iterator();
while (iterator.hasNext()) {
manager.addRecentWorkingSet(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<IWorkingSet> globals= new HashSet<IWorkingSet>(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<IWorkingSet> toMoveUp) {
if (toMoveUp.size() > 0) {
setElements(moveUp(fAllWorkingSets, toMoveUp));
fTableViewer.reveal(toMoveUp.get(0));
}
}
private void moveDown(List<IWorkingSet> toMoveDown) {
if (toMoveDown.size() > 0) {
setElements(reverse(moveUp(reverse(fAllWorkingSets), toMoveDown)));
fTableViewer.reveal(toMoveDown.get(toMoveDown.size() - 1));
}
}
private void setElements(List<IWorkingSet> elements) {
fAllWorkingSets= elements;
fTableViewer.setInput(fAllWorkingSets);
updateButtonAvailability();
}
private List<IWorkingSet> moveUp(List<IWorkingSet> elements, List<IWorkingSet> move) {
int nElements= elements.size();
List<IWorkingSet> res= new ArrayList<IWorkingSet>(nElements);
IWorkingSet floating= null;
for (int i= 0; i < nElements; i++) {
IWorkingSet 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<IWorkingSet> reverse(List<IWorkingSet> p) {
List<IWorkingSet> reverse= new ArrayList<IWorkingSet>(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<IWorkingSet> 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 WorkingSetComparator getComparator() {
if (fComparator == null) {
fComparator= new WorkingSetComparator(true);
}
return fComparator;
}
/**
* Returns all the working sets.
*
* @return all the working sets
* @since 3.7
*/
public IWorkingSet[] getAllWorkingSets() {
return fAllWorkingSets.toArray(new IWorkingSet[fAllWorkingSets.size()]);
}
}