/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 * 
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.dltk.javascript.internal.ui.refactoring;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.eclipse.core.runtime.Assert;
import org.eclipse.dltk.internal.javascript.corext.refactoring.ParameterInfo;
import org.eclipse.dltk.internal.ui.dialogs.TableTextCellEditor;
import org.eclipse.dltk.internal.ui.dialogs.TextFieldNavigationHandler;
import org.eclipse.dltk.internal.ui.refactoring.RefactoringMessages;
import org.eclipse.dltk.internal.ui.util.SWTUtil;
import org.eclipse.dltk.internal.ui.util.TableLayoutComposite;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.viewers.ICellModifier;
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.ITableFontProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.graphics.Font;
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.Label;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;

/**
 * A special control to edit and reorder method parameters.
 */
public class ChangeParametersControl extends Composite {
	public enum Mode {
		EXTRACT_METHOD, CHANGE_METHOD_SIGNATURE, INTRODUCE_PARAMETER;
		/*
		 * private final String fName; private Mode(String name) { fName= name;
		 * } public static final Mode EXTRACT_METHOD= new
		 * Mode("EXTRACT_METHOD"); //$NON-NLS-1$ public static final Mode
		 * CHANGE_METHOD_SIGNATURE= new Mode("CHANGE_METHOD_SIGNATURE");
		 * //$NON-NLS-1$ public static final Mode INTRODUCE_PARAMETER= new
		 * Mode("INTRODUCE_PARAMETER"); //$NON-NLS-1$ public String toString() {
		 * return fName; }
		 */
		public boolean canChangeTypes() {
			return this == CHANGE_METHOD_SIGNATURE;
		}

		public boolean canAddParameters() {
			return this == Mode.CHANGE_METHOD_SIGNATURE;
		}

		public boolean canChangeDefault() {
			return this == Mode.CHANGE_METHOD_SIGNATURE;
		}
	}

	private static class ParameterInfoContentProvider implements
			IStructuredContentProvider {
		public Object[] getElements(Object inputElement) {
			return removeMarkedAsDeleted((List<ParameterInfo>) inputElement);
		}

		private ParameterInfo[] removeMarkedAsDeleted(
				List<ParameterInfo> paramInfos) {
			List<ParameterInfo> result = new ArrayList<ParameterInfo>(
					paramInfos.size());
			for (ParameterInfo info : paramInfos) {
				if (!info.isDeleted())
					result.add(info);
			}
			return result.toArray(new ParameterInfo[result.size()]);
		}

		public void dispose() {
			// do nothing
		}

		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			// do nothing
		}
	}

	private static class ParameterInfoLabelProvider extends LabelProvider
			implements ITableLabelProvider, ITableFontProvider {
		public Image getColumnImage(Object element, int columnIndex) {
			return null;
		}

		public String getColumnText(Object element, int columnIndex) {
			ParameterInfo info = (ParameterInfo) element;
			switch (columnIndex) {
			// case TYPE_PROP:
			// return info.getNewTypeName();
			case NEWNAME_PROP:
				return info.getNewName();
			case DEFAULT_PROP:
				if (info.isAdded())
					return info.getDefaultValue();
				else
					return "-"; //$NON-NLS-1$
			default:
				throw new IllegalArgumentException(columnIndex + ": " + element); //$NON-NLS-1$
			}
		}

		public Font getFont(Object element, int columnIndex) {
			ParameterInfo info = (ParameterInfo) element;
			if (info.isAdded())
				return JFaceResources.getFontRegistry().getBold(
						JFaceResources.DIALOG_FONT);
			else
				return null;
		}
	}

	private class ParametersCellModifier implements ICellModifier {
		public boolean canModify(Object element, String property) {
			Assert.isTrue(element instanceof ParameterInfo);
			/*
			 * if (property.equals(PROPERTIES[TYPE_PROP])) return
			 * fMode.canChangeTypes(); else
			 */if (property.equals(PROPERTIES[NEWNAME_PROP]))
				return true;
			else if (property.equals(PROPERTIES[DEFAULT_PROP]))
				return (((ParameterInfo) element).isAdded());
			Assert.isTrue(false);
			return false;
		}

		public Object getValue(Object element, String property) {
			Assert.isTrue(element instanceof ParameterInfo);
			/*
			 * if (property.equals(PROPERTIES[TYPE_PROP])) return
			 * ((ParameterInfo) element).getNewTypeName(); else
			 */if (property.equals(PROPERTIES[NEWNAME_PROP]))
				return ((ParameterInfo) element).getNewName();
			else if (property.equals(PROPERTIES[DEFAULT_PROP]))
				return ((ParameterInfo) element).getDefaultValue();
			Assert.isTrue(false);
			return null;
		}

		public void modify(Object element, String property, Object value) {
			if (element instanceof TableItem)
				element = ((TableItem) element).getData();
			if (!(element instanceof ParameterInfo))
				return;
			boolean unchanged;
			ParameterInfo parameterInfo = (ParameterInfo) element;
			if (property.equals(PROPERTIES[NEWNAME_PROP])) {
				unchanged = parameterInfo.getNewName().equals(value);
				parameterInfo.setNewName((String) value);
			} else if (property.equals(PROPERTIES[DEFAULT_PROP])) {
				unchanged = parameterInfo.getDefaultValue().equals(value);
				parameterInfo.setDefaultValue((String) value);
				/*
				 * } else if (property.equals(PROPERTIES[TYPE_PROP])) {
				 * unchanged= parameterInfo.getNewTypeName().equals(value);
				 * parameterInfo.setNewTypeName((String) value);
				 */
			} else {
				throw new IllegalStateException();
			}
			if (!unchanged) {
				ChangeParametersControl.this.fListener
						.parameterChanged(parameterInfo);
				ChangeParametersControl.this.fTableViewer.update(parameterInfo,
						new String[] { property });
			}
		}
	}

	private static final String[] PROPERTIES = { /* "type", */"new", "default" }; //$NON-NLS-2$ //$NON-NLS-1$ //$NON-NLS-3$
	// private static final int TYPE_PROP= 0;
	private static final int NEWNAME_PROP = 0;
	private static final int DEFAULT_PROP = 1;

	private static final int ROW_COUNT = 7;

	private final Mode fMode;
	private final IParameterListChangeListener fListener;
	private List<ParameterInfo> fParameterInfos;
	/*
	 * private final StubTypeContext fTypeContext; private final String[]
	 * fParamNameProposals; private ContentAssistHandler
	 * fNameContentAssistHandler;
	 */

	private TableViewer fTableViewer;
	private Button fUpButton;
	private Button fDownButton;
	private Button fEditButton;
	private Button fAddButton;
	private Button fRemoveButton;

	/*
	 * public ChangeParametersControl(Composite parent, int style, String label,
	 * IParameterListChangeListener listener, Mode mode, StubTypeContext
	 * typeContext) { this(parent, style, label, listener, mode, typeContext,
	 * new String[0]); }
	 * 
	 * public ChangeParametersControl(Composite parent, int style, String label,
	 * IParameterListChangeListener listener, Mode mode) { this(parent, style,
	 * label, listener, mode, null, new String[0]); }
	 * 
	 * public ChangeParametersControl(Composite parent, int style, String label,
	 * IParameterListChangeListener listener, Mode mode, String[]
	 * paramNameProposals) { this(parent, style, label, listener, mode, null,
	 * paramNameProposals); }
	 */

	/**
	 * @param label
	 *            the label before the table or <code>null</code>
	 * @param typeContext
	 *            the package in which to complete types
	 */
	public ChangeParametersControl(Composite parent, int style, String label,
			IParameterListChangeListener listener, Mode mode/*
															 * , StubTypeContext
															 * typeContext
															 */) {
		super(parent, style);
		Assert.isNotNull(listener);
		fListener = listener;
		fMode = mode;
		// fTypeContext= typeContext;
		// fParamNameProposals= paramNameProposals;

		GridLayout layout = new GridLayout();
		layout.numColumns = 2;
		layout.marginWidth = 0;
		layout.marginHeight = 0;
		setLayout(layout);

		if (label != null) {
			Label tableLabel = new Label(this, SWT.NONE);
			GridData labelGd = new GridData();
			labelGd.horizontalSpan = 2;
			tableLabel.setLayoutData(labelGd);
			tableLabel.setText(label);
		}

		createParameterList(this);
		createButtonComposite(this);
	}

	public void setInput(List<ParameterInfo> parameterInfos) {
		Assert.isNotNull(parameterInfos);
		fParameterInfos = parameterInfos;
		fTableViewer.setInput(fParameterInfos);
		if (fParameterInfos.size() > 0)
			fTableViewer.setSelection(new StructuredSelection(fParameterInfos
					.get(0)));
	}

	public void editParameter(ParameterInfo info) {
		fTableViewer.getControl().setFocus();
		if (!info.isDeleted()) {
			fTableViewer.setSelection(new StructuredSelection(info), true);
			updateButtonsEnabledState();
			editColumnOrNextPossible(NEWNAME_PROP);
			return;
		}
	}

	// ---- Parameter table
	// -----------------------------------------------------------------------------------

	private void createParameterList(Composite parent) {
		TableLayoutComposite layouter = new TableLayoutComposite(parent,
				SWT.NONE);
		addColumnLayoutData(layouter);

		final Table table = new Table(layouter, SWT.MULTI | SWT.BORDER
				| SWT.FULL_SELECTION);
		table.setHeaderVisible(true);
		table.setLinesVisible(true);
		TableColumn tc;
		// tc= new TableColumn(table, SWT.NONE, TYPE_PROP);
		// tc.setResizable(true);
		// tc.setText(RefactoringMessages.ChangeParametersControl_table_type);

		tc = new TableColumn(table, SWT.NONE, NEWNAME_PROP);
		tc.setResizable(true);
		tc.setText(RefactoringMessages.ChangeParametersControl_table_name);

		if (fMode.canChangeDefault()) {
			tc = new TableColumn(table, SWT.NONE, DEFAULT_PROP);
			tc.setResizable(true);
			tc.setText(RefactoringMessages.ChangeParametersControl_table_defaultValue);
		}

		GridData gd = new GridData(GridData.FILL_BOTH);
		gd.heightHint = SWTUtil.getTableHeightHint(table, ROW_COUNT);
		gd.widthHint = 40;
		layouter.setLayoutData(gd);

		fTableViewer = new TableViewer(table);
		fTableViewer.setUseHashlookup(true);
		fTableViewer.setContentProvider(new ParameterInfoContentProvider());
		fTableViewer.setLabelProvider(new ParameterInfoLabelProvider());
		fTableViewer
				.addSelectionChangedListener(new ISelectionChangedListener() {
					public void selectionChanged(SelectionChangedEvent event) {
						updateButtonsEnabledState();
					}
				});

		table.addTraverseListener(new TraverseListener() {
			public void keyTraversed(TraverseEvent e) {
				if (e.detail == SWT.TRAVERSE_RETURN && e.stateMask == SWT.NONE) {
					editColumnOrNextPossible(0);
					e.detail = SWT.TRAVERSE_NONE;
				}
			}
		});
		table.addKeyListener(new KeyAdapter() {
			public void keyPressed(KeyEvent e) {
				if (e.keyCode == SWT.F2 && e.stateMask == SWT.NONE) {
					editColumnOrNextPossible(0);
					e.doit = false;
				}
			}
		});

		addCellEditors();
	}

	private void editColumnOrNextPossible(int column) {
		ParameterInfo[] selected = getSelectedElements();
		if (selected.length != 1)
			return;
		int nextColumn = column;
		do {
			fTableViewer.editElement(selected[0], nextColumn);
			if (fTableViewer.isCellEditorActive())
				return;
			nextColumn = nextColumn(nextColumn);
		} while (nextColumn != column);
	}

	private void editColumnOrPrevPossible(int column) {
		ParameterInfo[] selected = getSelectedElements();
		if (selected.length != 1)
			return;
		int prevColumn = column;
		do {
			fTableViewer.editElement(selected[0], prevColumn);
			if (fTableViewer.isCellEditorActive())
				return;
			prevColumn = prevColumn(prevColumn);
		} while (prevColumn != column);
	}

	private int nextColumn(int column) {
		return (column >= getTable().getColumnCount() - 1) ? 0 : column + 1;
	}

	private int prevColumn(int column) {
		return (column <= 0) ? getTable().getColumnCount() - 1 : column - 1;
	}

	private void addColumnLayoutData(TableLayoutComposite layouter) {
		if (fMode.canChangeDefault()) {
			// layouter.addColumnData(new ColumnWeightData(33, true));
			layouter.addColumnData(new ColumnWeightData(33, true));
			layouter.addColumnData(new ColumnWeightData(34, true));
		} else {
			// layouter.addColumnData(new ColumnWeightData(50, true));
			layouter.addColumnData(new ColumnWeightData(50, true));
		}
	}

	private ParameterInfo[] getSelectedElements() {
		ISelection selection = fTableViewer.getSelection();
		if (selection == null)
			return new ParameterInfo[0];

		if (!(selection instanceof IStructuredSelection))
			return new ParameterInfo[0];

		List<ParameterInfo> selected = ((IStructuredSelection) selection)
				.toList();
		return (ParameterInfo[]) selected.toArray(new ParameterInfo[selected
				.size()]);
	}

	// ---- Button bar
	// --------------------------------------------------------------------------------------

	private void createButtonComposite(Composite parent) {
		Composite buttonComposite = new Composite(parent, SWT.NONE);
		buttonComposite.setLayoutData(new GridData(GridData.FILL_VERTICAL));
		GridLayout gl = new GridLayout();
		gl.marginHeight = 0;
		gl.marginWidth = 0;
		buttonComposite.setLayout(gl);

		if (fMode.canAddParameters())
			fAddButton = createAddButton(buttonComposite);

		fEditButton = createEditButton(buttonComposite);

		if (fMode.canAddParameters())
			fRemoveButton = createRemoveButton(buttonComposite);

		if (buttonComposite.getChildren().length != 0)
			addSpacer(buttonComposite);

		fUpButton = createButton(buttonComposite,
				RefactoringMessages.ChangeParametersControl_buttons_move_up,
				true);
		fDownButton = createButton(buttonComposite,
				RefactoringMessages.ChangeParametersControl_buttons_move_down,
				false);

		updateButtonsEnabledState();
	}

	private void addSpacer(Composite parent) {
		Label label = new Label(parent, SWT.NONE);
		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.heightHint = 5;
		label.setLayoutData(gd);
	}

	private void updateButtonsEnabledState() {
		fUpButton.setEnabled(canMove(true));
		fDownButton.setEnabled(canMove(false));
		if (fEditButton != null)
			fEditButton.setEnabled(getTableSelectionCount() == 1);
		if (fAddButton != null)
			fAddButton.setEnabled(true);
		if (fRemoveButton != null)
			fRemoveButton.setEnabled(getTableSelectionCount() != 0);
	}

	private int getTableSelectionCount() {
		return getTable().getSelectionCount();
	}

	private int getTableItemCount() {
		return getTable().getItemCount();
	}

	private Table getTable() {
		return fTableViewer.getTable();
	}

	private Button createEditButton(Composite buttonComposite) {
		Button button = new Button(buttonComposite, SWT.PUSH);
		button.setText(RefactoringMessages.ChangeParametersControl_buttons_edit);
		button.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		SWTUtil.setButtonDimensionHint(button);
		button.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				try {
					ParameterInfo[] selected = getSelectedElements();
					Assert.isTrue(selected.length == 1);
					ParameterInfo parameterInfo = selected[0];
					ParameterEditDialog dialog = new ParameterEditDialog(
							getShell(), parameterInfo, fMode.canChangeTypes(),
							fMode.canChangeDefault()/* , fTypeContext */);
					dialog.open();
					fListener.parameterChanged(parameterInfo);
					fTableViewer.update(parameterInfo, PROPERTIES);
				} finally {
					fTableViewer.getControl().setFocus();
				}
			}
		});
		return button;
	}

	private Button createAddButton(Composite buttonComposite) {
		Button button = new Button(buttonComposite, SWT.PUSH);
		button.setText(RefactoringMessages.ChangeParametersControl_buttons_add);
		button.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		SWTUtil.setButtonDimensionHint(button);
		button.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				String[] excludedParamNames = new String[fParameterInfos.size()];
				for (int i = 0; i < fParameterInfos.size(); i++) {
					ParameterInfo info = (ParameterInfo) fParameterInfos.get(i);
					excludedParamNames[i] = info.getNewName();
				}
				// IJavaProject javaProject=
				// fTypeContext.getCuHandle().getJavaProject();
				// String newParamName=
				// StubUtility.suggestArgumentName(javaProject,
				// RefactoringMessages.ChangeParametersControl_new_parameter_default_name,
				// excludedParamNames);
				ParameterInfo newInfo = ParameterInfo
						.createInfoForAddedParameter("", "", "undefined"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
				int insertIndex = fParameterInfos.size();
				for (int i = fParameterInfos.size() - 1; i >= 0; i--) {
					ParameterInfo info = (ParameterInfo) fParameterInfos.get(i);
					/*
					 * if (info.isNewVarargs()) { insertIndex= i; break; }
					 */
				}
				fParameterInfos.add(insertIndex, newInfo);
				fListener.parameterAdded(newInfo);
				fTableViewer.refresh();
				fTableViewer.getControl().setFocus();
				fTableViewer.setSelection(new StructuredSelection(newInfo),
						true);
				updateButtonsEnabledState();
				editColumnOrNextPossible(0);
			}
		});
		return button;
	}

	private Button createRemoveButton(Composite buttonComposite) {
		final Button button = new Button(buttonComposite, SWT.PUSH);
		button.setText(RefactoringMessages.ChangeParametersControl_buttons_remove);
		button.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		SWTUtil.setButtonDimensionHint(button);
		button.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				int index = getTable().getSelectionIndices()[0];
				ParameterInfo[] selected = getSelectedElements();
				for (int i = 0; i < selected.length; i++) {
					if (selected[i].isAdded())
						fParameterInfos.remove(selected[i]);
					else
						selected[i].markAsDeleted();
				}
				restoreSelection(index);
			}

			private void restoreSelection(int index) {
				fTableViewer.refresh();
				fTableViewer.getControl().setFocus();
				int itemCount = getTableItemCount();
				if (itemCount != 0) {
					if (index >= itemCount)
						index = itemCount - 1;
					getTable().setSelection(index);
				}
				fListener.parameterListChanged();
				updateButtonsEnabledState();
			}
		});
		return button;
	}

	private Button createButton(Composite buttonComposite, String text,
			final boolean up) {
		Button button = new Button(buttonComposite, SWT.PUSH);
		button.setText(text);
		button.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		SWTUtil.setButtonDimensionHint(button);
		button.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				ISelection savedSelection = fTableViewer.getSelection();
				if (savedSelection == null)
					return;
				ParameterInfo[] selection = getSelectedElements();
				if (selection.length == 0)
					return;

				if (up) {
					moveUp(selection);
				} else {
					moveDown(selection);
				}
				fTableViewer.refresh();
				fTableViewer.setSelection(savedSelection);
				fListener.parameterListChanged();
				fTableViewer.getControl().setFocus();
			}
		});
		return button;
	}

	// ---- editing
	// -----------------------------------------------------------------------------------------------

	private void addCellEditors() {
		fTableViewer.setColumnProperties(PROPERTIES);

		final TableTextCellEditor editors[] = new TableTextCellEditor[PROPERTIES.length];

		// editors[TYPE_PROP]= new TableTextCellEditor(fTableViewer, TYPE_PROP);
		editors[NEWNAME_PROP] = new TableTextCellEditor(fTableViewer,
				NEWNAME_PROP);
		editors[DEFAULT_PROP] = new TableTextCellEditor(fTableViewer,
				DEFAULT_PROP);

		/*
		 * if (fMode.canChangeTypes()) { SubjectControlContentAssistant
		 * assistant=
		 * installParameterTypeContentAssist(editors[TYPE_PROP].getText());
		 * editors[TYPE_PROP].setContentAssistant(assistant); } if
		 * (fParamNameProposals.length > 0) { SubjectControlContentAssistant
		 * assistant=
		 * installParameterNameContentAssist(editors[NEWNAME_PROP].getText());
		 * editors[NEWNAME_PROP].setContentAssistant(assistant); }
		 */

		for (int i = 0; i < editors.length; i++) {
			final int editorColumn = i;
			final TableTextCellEditor editor = editors[i];
			// support tabbing between columns while editing:
			editor.getText().addTraverseListener(new TraverseListener() {
				public void keyTraversed(TraverseEvent e) {
					switch (e.detail) {
					case SWT.TRAVERSE_TAB_NEXT:
						editColumnOrNextPossible(nextColumn(editorColumn));
						e.detail = SWT.TRAVERSE_NONE;
						break;

					case SWT.TRAVERSE_TAB_PREVIOUS:
						editColumnOrPrevPossible(prevColumn(editorColumn));
						e.detail = SWT.TRAVERSE_NONE;
						break;

					default:
						break;
					}
				}
			});
			TextFieldNavigationHandler.install(editor.getText());
		}

		/*
		 * editors[NEWNAME_PROP].setActivationListener(new
		 * TableTextCellEditor.IActivationListener(){ public void activate() {
		 * ParameterInfo[] selected= getSelectedElements(); if (selected.length
		 * == 1 && fNameContentAssistHandler != null) {
		 * fNameContentAssistHandler.setEnabled(selected[0].isAdded()); } } });
		 */

		fTableViewer.setCellEditors(editors);
		fTableViewer.setCellModifier(new ParametersCellModifier());
	}

	/*
	 * private SubjectControlContentAssistant
	 * installParameterTypeContentAssist(Text text) {
	 * JavaTypeCompletionProcessor processor= new
	 * JavaTypeCompletionProcessor(true, false); if (fTypeContext == null)
	 * processor.setCompletionContext(null, null, null); else
	 * processor.setCompletionContext(fTypeContext.getCuHandle(),
	 * fTypeContext.getBeforeString(), fTypeContext.getAfterString());
	 * SubjectControlContentAssistant contentAssistant=
	 * ControlContentAssistHelper.createJavaContentAssistant(processor);
	 * ContentAssistHandler.createHandlerForText(text, contentAssistant); return
	 * contentAssistant; }
	 * 
	 * private SubjectControlContentAssistant
	 * installParameterNameContentAssist(Text text) { VariableNamesProcessor
	 * processor= new VariableNamesProcessor(fParamNameProposals);
	 * SubjectControlContentAssistant contentAssistant=
	 * ControlContentAssistHelper.createJavaContentAssistant(processor);
	 * fNameContentAssistHandler=
	 * ContentAssistHandler.createHandlerForText(text, contentAssistant); return
	 * contentAssistant; }
	 */

	// ---- change order
	// ----------------------------------------------------------------------------------------

	private void moveUp(ParameterInfo[] selection) {
		moveUp(fParameterInfos, Arrays.asList(selection));
	}

	private void moveDown(ParameterInfo[] selection) {
		Collections.reverse(fParameterInfos);
		moveUp(fParameterInfos, Arrays.asList(selection));
		Collections.reverse(fParameterInfos);
	}

	private static void moveUp(List<ParameterInfo> elements,
			List<ParameterInfo> move) {
		List<ParameterInfo> res = new ArrayList<ParameterInfo>(elements.size());
		List<ParameterInfo> deleted = new ArrayList<ParameterInfo>();
		ParameterInfo floating = null;
		for (ParameterInfo curr : elements) {
			if (move.contains(curr)) {
				res.add(curr);
			} else if (((ParameterInfo) curr).isDeleted()) {
				deleted.add(curr);
			} else {
				if (floating != null)
					res.add(floating);
				floating = curr;
			}
		}
		if (floating != null) {
			res.add(floating);
		}
		res.addAll(deleted);
		elements.clear();
		for (ParameterInfo element : res) {
			elements.add(element);
		}
	}

	private boolean canMove(boolean up) {
		int notDeletedInfosCount = getNotDeletedInfosCount();
		if (notDeletedInfosCount == 0)
			return false;
		int[] indc = getTable().getSelectionIndices();
		if (indc.length == 0)
			return false;
		int invalid = up ? 0 : notDeletedInfosCount - 1;
		for (int i = 0; i < indc.length; i++) {
			if (indc[i] == invalid)
				return false;
		}
		return true;
	}

	private int getNotDeletedInfosCount() {
		if (fParameterInfos == null) // during initialization
			return 0;
		int result = 0;
		for (ParameterInfo info : fParameterInfos) {
			if (!info.isDeleted())
				result++;
		}
		return result;
	}
}