/*******************************************************************************
* Copyright (c) 2000, 2008 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.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;
}
}