AbstractEditParametersDialog.java

/*******************************************************************************
 * Copyright (c) 2004, 2010 BREDEX GmbH.
 * 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:
 *     BREDEX GmbH - initial API and implementation and/or initial documentation
 *******************************************************************************/
package org.eclipse.jubula.client.ui.rcp.dialogs;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.TitleAreaDialog;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ComboBoxCellEditor;
import org.eclipse.jface.viewers.ICellModifier;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.window.Window;
import org.eclipse.jubula.client.core.model.IParamDescriptionPO;
import org.eclipse.jubula.client.core.model.IParameterInterfacePO;
import org.eclipse.jubula.client.ui.constants.ContextHelpIds;
import org.eclipse.jubula.client.ui.constants.IconConstants;
import org.eclipse.jubula.client.ui.rcp.Plugin;
import org.eclipse.jubula.client.ui.rcp.i18n.Messages;
import org.eclipse.jubula.client.ui.utils.ErrorHandlingUtil;
import org.eclipse.jubula.client.ui.utils.LayoutUtil;
import org.eclipse.jubula.toolkit.common.xml.businessprocess.ComponentBuilder;
import org.eclipse.jubula.tools.internal.constants.StringConstants;
import org.eclipse.jubula.tools.internal.constants.TestDataConstants;
import org.eclipse.jubula.tools.internal.exception.Assert;
import org.eclipse.jubula.tools.internal.i18n.CompSystemI18n;
import org.eclipse.jubula.tools.internal.messagehandling.MessageIDs;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.events.VerifyEvent;
import org.eclipse.swt.events.VerifyListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
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.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Text;


/**
 * @author BREDEX GmbH
 * @created Oct 25, 2007
 */
@SuppressWarnings("synthetic-access")
public abstract class AbstractEditParametersDialog extends TitleAreaDialog {

    /** 
     * Regex for param name input validation. This allows all letters and 
     * numbers as well as the empty string. It can be used for controlling the
     * input of a text field, but should not be used for final validation, as it
     * allows empty strings. 
     */
    private static final String PARAM_NAME_REGEX = "[a-zA-Z_0-9]*"; //$NON-NLS-1$

    /**
     * <code>DEFAULT_COLUMN_WIDTH</code>
     */
    private static final int DEFAULT_COLUMN_WIDTH = 200;

    /**
     * <code>INITIAL_SIZE</code> of this Dialog.
     */
    private static final int INITIAL_SIZE = 600;

    /** Name of the name-column */
    private static final String NAME_COL_NAME = 
        Messages.EditParametersDialogNameTableColumnName;
    
    /** Name of the type-column */
    private static final String TYPE_COL_NAME = 
        Messages.EditParametersDialogTypeTableColumnName;
    
    /** Constant for an empty Cell entry */
    private static final String EMPTY_ENTRY = StringUtils.EMPTY;
    
    /** Default name of a new added Parameter */
    private static final String DEFAULT_PARAM_NAME = 
        Messages.EditParametersDialogDefaultNewParameterName;
    
    /** Default type of a new added Parameter */
    private static final String DEFAULT_PARAM_TYPE = TestDataConstants.STR;
    
    /**
     * <code>ERROR_COLOR</code>
     */
    private static final int ERROR_COLOR = SWT.COLOR_RED;
    
    /** Constant for the index of the name column of the table */
    private static final int NAME_TABLE_COLUMN = 0;
    
    /** Constant for the index of the type column of the table */
    private static final int TYPE_TABLE_COLUMN = 1;
    
    /**
     * <code>TABLE_COLUMNS</code>
     */
    private static final String[] TABLE_COLUMNS = 
        new String[]{NAME_COL_NAME, TYPE_COL_NAME};

    /** The IParameterInterfacePO */
    private IParameterInterfacePO m_paramInterfaceObj;
    
    /** The inner data model of the parameters */
    private List<Parameter> m_parameters = new ArrayList<Parameter>();
    
    /** The TableViewer */
    private TableViewer m_paramTableViewer;

    /**
     * @param parentShell
     *            the parent.
     * @param paramIntObj
     *            parameter interface obj the IParameterInterfacePO.
     */
    public AbstractEditParametersDialog(Shell parentShell,
            IParameterInterfacePO paramIntObj) {
        super(parentShell);
        setParamInterfaceObj(paramIntObj);
    }
    
    /**
     * {@inheritDoc}
     */
    protected Point getInitialSize() {
        final Point initialSize = super.getInitialSize();
        initialSize.y = INITIAL_SIZE;
        return initialSize;
    }
    
    /**
     * @author BREDEX GmbH
     * @created Mar 17, 2008
     */
    protected final class SelectionBasedButtonEnabler implements
            ISelectionChangedListener, SelectionListener {
        /** <code>Button</code> */
        private final Button m_button;

        /** @param button a Button */
        private SelectionBasedButtonEnabler(Button button) {
            m_button = button;
        }
        
        /** {@inheritDoc} */
        public void selectionChanged(SelectionChangedEvent event) {
            handleSelection();
        }
        
        /** {@inheritDoc} */
        public void widgetDefaultSelected(SelectionEvent e) {
            handleSelection();
        }

        /** {@inheritDoc} */
        public void widgetSelected(SelectionEvent e) {
            handleSelection();
        }
        
        /**
         * handle the selection
         */
        private void handleSelection() {
            m_button.setEnabled(generalButtonEnablement()
                    && !getParamTableViewer().getSelection().isEmpty());
        }
    }

    /**
     * @return wheter all buttons add, delete, up, down shall be enabled on
     *         selection changed events
     */
    protected boolean generalButtonEnablement() {
        return true;
    }
    
    /**
     * ContentProvider of the ParameterTable
     * @author BREDEX GmbH
     * @created Oct 25, 2007
     */
    private static final class ParamTableContentProvider implements 
        IStructuredContentProvider {

        /** {@inheritDoc} */
        public Object[] getElements(Object inputElement) {
            return ((List)inputElement).toArray();
        }

        /** {@inheritDoc} */
        public void dispose() {
            // nothing
        }

        /** {@inheritDoc} */
        public void inputChanged(Viewer viewer, Object oldInput, 
            Object newInput) {
            // nothing
        }
    }
    
    /**
     * LabelProvider of the ParameterTable
     * 
     * @author BREDEX GmbH
     * @created Oct 25, 2007
     */
    private final class ParamTableLabelProvider implements 
        ITableLabelProvider {

        /** {@inheritDoc} */
        public Image getColumnImage(Object element, int columnIndex) {
            if (columnIndex == NAME_TABLE_COLUMN) {
                final Parameter parameter = (Parameter)element;
                if (EMPTY_ENTRY.equals(parameter.getName().trim())
                    || EMPTY_ENTRY.equals(parameter.getType().trim())
                    || isDuplicate(parameter)) {
                    
                    return IconConstants.ERROR_IMAGE;
                } 
            }
            return null;
        }

        /** {@inheritDoc} */
        public String getColumnText(Object element, int columnIndex) {
            final Parameter parameter = (Parameter)element;
            final String text = getTableCellText(parameter, columnIndex);
            setCellBackground(parameter);
            return text;
        }


        /**
         * Sets the background of the cell of the given parameter.
         * @param parameter A Parameter.
         */
        private void setCellBackground(Parameter parameter) {
            
            final Table table = getParamTableViewer().getTable();
            Color rowColor = null; // null sets default color!
            if (EMPTY_ENTRY.equals(parameter.getName().trim())
                || EMPTY_ENTRY.equals(parameter.getType().trim())
                || isDuplicate(parameter)) {
                
                rowColor = table.getDisplay().getSystemColor(ERROR_COLOR);
            } 
            final Integer[] indices = getIndices(parameter);
            final int itemCount = table.getItemCount();
            for (int index : indices) {
                if (index < itemCount) {
                    final TableItem item = table.getItem(index);
                    item.setBackground(NAME_TABLE_COLUMN, rowColor);   
                }
            }
        }

        /** {@inheritDoc} */
        public void addListener(ILabelProviderListener listener) {
            // nothing
        }

        /** {@inheritDoc} */
        public void dispose() {
            // nothing
        }

        /** {@inheritDoc} */
        public boolean isLabelProperty(Object element, String property) {
            return false;
        }

        /** {@inheritDoc} */
        public void removeListener(ILabelProviderListener listener) {
            // nothing
        }
        
    }
    
    /**
     * @author BREDEX GmbH
     * @created Oct 26, 2007
     */
    private static final  class I18nComboBoxCellEditor 
        extends ComboBoxCellEditor {
        
        /** The model items (no I18N) */
        private String[] m_modelItems;
        
        /**
         * @param parent the parent control
         * @param items the list of strings for the combo box
         * @param style the style bits
         */
        public I18nComboBoxCellEditor(Composite parent, String[] items, 
            int style) {
            
            super(parent, items, style);
            m_modelItems = items;
            translateModelItems();
        }

        /**
         * translates the model items
         */
        protected void translateModelItems() {
            final int itemSize = m_modelItems.length;
            final String[] translatedItems = new String[itemSize];
            int i = 0;
            for (String item : m_modelItems) {                
                final String translatedItem = CompSystemI18n.getString(item);
                translatedItems[i] = translatedItem;
                i++;
            }
            setItems(translatedItems);
        }
        
        /**
         * {@inheritDoc}
         * @return The non-I18N-Value of the current selection.
         */
        protected Object doGetValue() {
            final int selectedIndex = (Integer)super.doGetValue();
            return getModelItems()[selectedIndex];
        }

        /**
         * {@inheritDoc}
         */
        protected void doSetValue(Object value) {
            int index = Arrays.asList(getItems()).indexOf(value);
            if (index < 0) {
                index = 0;
            }
            super.doSetValue(Integer.valueOf(index));
        }
        
        /** 
         * @return The model Items (no I18N)
         */
        public String[] getModelItems() {
            return m_modelItems;
        }
        
    }
    
    
    /**
     * Inner data model for parameter
     * @author BREDEX GmbH
     * @created Oct 25, 2007
     */
    public static final class Parameter {
        
        /** The GUID */
        private String m_guid;
        /** The name */
        private String m_name = StringConstants.EMPTY;
        /** The type */
        private String m_type = StringConstants.EMPTY;

        
        /**
         * Constructor to create a new Parameter without GUID
         * @param name The name.
         * @param type The type.
         */
        public Parameter(String name, String type) {
            m_name = name;
            m_type = type;
        }
        
        /**
         * Constructor to create an already existing parameter with GUID
         * @param guid the GUID.
         * @param name The name.
         * @param type The type.
         */
        public Parameter(String guid, String name, String type) {
            this(name, type);
            m_guid = guid;
        }

        /**
         * Copy constructor from an already existing parameter description.
         * @param descr The parameter description.
         */
        public Parameter(IParamDescriptionPO descr) {
            this(descr.getUniqueId(), descr.getName(), descr.getType());
        }

        /**
         * @return the name or an empty String if no name is set.
         */
        public String getName() {
            return m_name;
        }

        /**
         * @param name the name to set
         */
        public void setName(String name) {
            if (name == null) {
                m_name = EMPTY_ENTRY;
            } else {
                m_name = name;                
            }
        }

        /**
         * @return The type or an empty String if no type is set.
         */
        public String getType() {
            return m_type;
        }

        /**
         * @param type The type to set
         */
        public void setType(String type) {
            if (type == null) {
                m_type = EMPTY_ENTRY;
            } else {                
                m_type = type;
            }
        }

        /**
         * @return The GUID or null if this is a new created Parameter.
         */
        public String getGuid() {
            return m_guid;
        }
        
        /**
         * {@inheritDoc}
         */
        public int hashCode() {
            return m_name.hashCode();
        }
        
    }
    
    /**
     * @author BREDEX GmbH
     * @created Oct 25, 2007
     */
    protected abstract class AbstractTableCellModifier 
        implements ICellModifier {

        /**
         * {@inheritDoc}
         */
        public abstract boolean canModify(Object element, String property);

        /**
         * {@inheritDoc}
         */
        public Object getValue(Object element, String property) {
            final int columnIndex = getColumnIndex(property);
            return getTableCellText((Parameter)element, columnIndex);
        }

        /**
         * {@inheritDoc}
         */
        public void modify(Object element, String property, Object value) {
            final TableItem tableItem = (TableItem)element;
            final Parameter parameter = (Parameter)tableItem.getData();
            final int columnIndex = getColumnIndex(property);
            setTableCellText(value, parameter, columnIndex);
        }
    }
    
    /**
     * {@inheritDoc}
     */
    protected Control createDialogArea(Composite parent) {
        final GridLayout gridLayoutParent = new GridLayout();
        gridLayoutParent.numColumns = 1;
        parent.setLayout(gridLayoutParent);
        LayoutUtil.createSeparator(parent);
        final Composite area = new Composite(parent, SWT.NONE);
        final GridLayout areaLayout = new GridLayout();
        area.setLayout(areaLayout);
        final GridData areaGridData = new GridData();
        areaGridData.grabExcessVerticalSpace = true;
        areaGridData.horizontalAlignment = GridData.FILL;
        areaGridData.verticalAlignment = GridData.FILL;
        area.setLayoutData(areaGridData);

        createNameField(area);
        LayoutUtil.createSeparator(area);
        createParameterTableArea(area);
        LayoutUtil.createSeparator(area);
        refreshTable();
        // add help id and tell eclipse that it's there
        Plugin.getHelpSystem().setHelp(parent, ContextHelpIds.EDIT_PARAMETERS);
        setHelpAvailable(true);

        return area;
    }

    /**
     * @param parent the parent
     */
    private void createParameterTableArea(Composite parent) {
        final Label label = new Label(parent, SWT.NONE);
        label.setText(Messages.EditParametersDialogParameters);
        
        createAdditionalWidgetsAtTop(parent);
        
        final Composite tableArea = new Composite(parent, SWT.NONE);
        final GridLayout areaLayout = new GridLayout(2, false);
        tableArea.setLayout(areaLayout);
        final GridData tableAreaGridData = new GridData();
        tableAreaGridData.grabExcessVerticalSpace = true;
        tableAreaGridData.horizontalAlignment = GridData.FILL;
        tableAreaGridData.verticalAlignment = GridData.FILL;
        tableArea.setLayoutData(tableAreaGridData);
        
        createParameterTable(tableArea);
        
        createTableButtons(tableArea);
    }

    /**
     * subclasses may override
     * @param parent the parent
     */
    protected void createAdditionalWidgetsAtTop(Composite parent) {
        // subclasses may override
    }

    /**
     * @param parent the parent
     */
    protected void createParameterTable(final Composite parent) {
        setParamTableViewer(new TableViewer(parent, 
            SWT.BORDER | SWT.SINGLE | SWT.FULL_SELECTION));
        createInnerDataModel();
        final GridData paramTableFieldGridData = new GridData();
        paramTableFieldGridData.grabExcessHorizontalSpace = true;
        paramTableFieldGridData.grabExcessVerticalSpace = true;
        paramTableFieldGridData.horizontalAlignment = GridData.FILL;
        paramTableFieldGridData.verticalAlignment = GridData.FILL;
        final Table table = getParamTableViewer().getTable();
        
        for (String columnText : TABLE_COLUMNS) {
            TableColumn column = new TableColumn(table, SWT.NONE);
            column.setText(columnText);
        }
        table.setHeaderVisible(true);
        table.setLinesVisible(true);
        table.setLayoutData(paramTableFieldGridData);
        for (TableColumn col : table.getColumns()) {
            col.setWidth(DEFAULT_COLUMN_WIDTH);
        }
        getParamTableViewer().setColumnProperties(TABLE_COLUMNS);
        getParamTableViewer().setContentProvider(
                new ParamTableContentProvider());
        getParamTableViewer().setLabelProvider(
                new ParamTableLabelProvider());
        getParamTableViewer().setInput(m_parameters);
        createTableCellEditors(table);
        getParamTableViewer().setCellModifier(getParamTableCellModifier());
        for (CellEditor cellEditor : getParamTableViewer().getCellEditors()) {
            cellEditor.getControl().addFocusListener(new FocusAdapter() {
                public void focusLost(FocusEvent e) {
                    checkOkButtonEnablement();
                }
            });
        }
    }

    /**
     * @return a valid cell table modifier
     */
    protected abstract ICellModifier getParamTableCellModifier();

    /**
     * Creates the {@link CellEditor}s of the given Table.
     * @param table a Table
     */
    private void createTableCellEditors(final Table table) {
        
        final TextCellEditor paramNameTextCellEditor = new TextCellEditor(
            table);
        ((Text)paramNameTextCellEditor.getControl()).addVerifyListener(
                new VerifyListener() {
                    
                    public void verifyText(VerifyEvent e) {
                        Text txt = (Text)e.widget;
                        final String oldValue = txt.getText();
                        StringBuilder workValue = new StringBuilder(oldValue);
                        workValue.replace(e.start, e.end, e.text);
                        String newValue = workValue.toString();
                        
                        e.doit = Pattern.matches(PARAM_NAME_REGEX, newValue);
                    }
            
                });
        final Set<String> paramTypes = ComponentBuilder.getInstance()
            .getCompSystem().getAllDataTypes();
        
        final I18nComboBoxCellEditor i18nParamTypesComboBoxEditor = 
            new I18nComboBoxCellEditor(table, 
                paramTypes.toArray(new String[paramTypes.size()]), 
                SWT.READ_ONLY);
        
        getParamTableViewer().setCellEditors(
            new CellEditor[]{paramNameTextCellEditor, 
                i18nParamTypesComboBoxEditor});
    }

    /**
     * Creates the inner data model (m_parameters)
     */
    private void createInnerDataModel() {
        if (!m_parameters.isEmpty()) {
            m_parameters.clear();
        }
        List<IParamDescriptionPO> parameterList = 
            getParamInterfaceObj().getParameterList();
        for (IParamDescriptionPO descr : parameterList) {
            m_parameters.add(new Parameter(descr));
        }
    }

    /**
     * @param parent the parent
     */
    private void createTableButtons(Composite parent) {
        final Composite tableButtonArea = new Composite(parent, SWT.NONE);
        final GridLayout areaLayout = new GridLayout(1, true);
        tableButtonArea.setLayout(areaLayout);
        final GridData tableAreaGridData = new GridData();
        tableAreaGridData.grabExcessVerticalSpace = true;
        tableAreaGridData.horizontalAlignment = GridData.FILL;
        tableAreaGridData.verticalAlignment = GridData.FILL;
        tableButtonArea.setLayoutData(tableAreaGridData);
        
        final GridData buttonsGridData = new GridData();
        buttonsGridData.grabExcessHorizontalSpace = true;
        buttonsGridData.horizontalAlignment = GridData.FILL;
        createAddButton(tableButtonArea, buttonsGridData);
        createDeleteButton(tableButtonArea, buttonsGridData);
        LayoutUtil.createSeparator(tableButtonArea);
        createUpButton(tableButtonArea, buttonsGridData);
        createDownButton(tableButtonArea, buttonsGridData);
    }

    /**
     * @param parent the parent
     * @param layoutData the LayoutData
     * @return the Delete-Button
     */
    private Button createDeleteButton(Composite parent, GridData layoutData) {
        final Button deleteButton = new Button(parent, SWT.NONE);
        deleteButton.setText(Messages.EditParametersDialogRemove);
        deleteButton.setLayoutData(layoutData);
        deleteButton.addSelectionListener(new SelectionListener() {
            
            public void widgetSelected(SelectionEvent e) {                
                handleSelection(e);
            }

            public void widgetDefaultSelected(SelectionEvent e) {
                handleSelection(e);
            }
            
            /**
             * Handles the selection
             * @param e SelectionEvent
             */
            private void handleSelection(SelectionEvent e) {
                removeSelectedParameter();
                checkOkButtonEnablement();
            }
        });
        final SelectionBasedButtonEnabler buttonEnabler = 
            new SelectionBasedButtonEnabler(deleteButton);
        getParamTableViewer().addSelectionChangedListener(buttonEnabler);
        afterDeleteButtonCreation(deleteButton, buttonEnabler);
        deleteButton.setEnabled(
                !getParamTableViewer().getSelection().isEmpty());
        return deleteButton;
    }


    /**
     * subclasses may override
     * @param deleteButton the delete button 
     * @param buttonEnabler the button enabler
     */
    protected void afterDeleteButtonCreation(Button deleteButton,
            SelectionBasedButtonEnabler buttonEnabler) {
        // subclasses may override
    }
    
    /**
     * @param parent the parent
     * @param layoutData the LayoutData
     * @return the Up-Button
     */
    private Button createUpButton(Composite parent, GridData layoutData) {
        final Button upButton = new Button(parent, SWT.NONE);
        upButton.setText(Messages.EditParametersDialogUp);
        upButton.setLayoutData(layoutData);
        upButton.addSelectionListener(new SelectionListener() {
            
            public void widgetSelected(SelectionEvent e) {                
                handleSelection(e);
            }

            public void widgetDefaultSelected(SelectionEvent e) {
                handleSelection(e);
            }
            
            /**
             * Handles the selection
             * @param e SelectionEvent
             */
            private void handleSelection(SelectionEvent e) {
                moveParameter(false);
            }
        });
        final SelectionBasedButtonEnabler buttonEnabler = 
            new SelectionBasedButtonEnabler(upButton);
        getParamTableViewer().addSelectionChangedListener(buttonEnabler);
        afterUpButtonCreation(upButton, buttonEnabler);
        upButton.setEnabled(!getParamTableViewer().getSelection().isEmpty());
        return upButton;
    }
    
    /**
     * subclasses may override
     * @param upButton the up button 
     * @param buttonEnabler the button enabler
     */
    protected void afterUpButtonCreation(Button upButton,
            SelectionBasedButtonEnabler buttonEnabler) {
        // subclasses may override
    }
    
    /**
     * @param parent the parent
     * @param layoutData the LayoutData
     * @return the Up-Button
     */
    private Button createDownButton(Composite parent, GridData layoutData) {
        final Button downButton = new Button(parent, SWT.NONE);
        downButton.setText(Messages.EditParametersDialogDown);
        downButton.setLayoutData(layoutData);
        downButton.addSelectionListener(new SelectionListener() {
            
            public void widgetSelected(SelectionEvent e) {                
                handleSelection(e);
            }

            public void widgetDefaultSelected(SelectionEvent e) {
                handleSelection(e);
            }
            
            /**
             * Handles the selection
             * @param e SelectionEvent
             */
            private void handleSelection(SelectionEvent e) {
                moveParameter(true);
            }
        });
        final SelectionBasedButtonEnabler buttonEnabler = 
            new SelectionBasedButtonEnabler(downButton);
        getParamTableViewer().addSelectionChangedListener(buttonEnabler);
        afterDownButtonCreation(downButton, buttonEnabler);
        downButton.setEnabled(!getParamTableViewer().getSelection().isEmpty());
        return downButton;
    }
    
    /**
     * subclasses may override
     * @param downButton the down button 
     * @param buttonEnabler the button enabler
     */
    protected void afterDownButtonCreation(Button downButton,
            SelectionBasedButtonEnabler buttonEnabler) {
        // subclasses may override
    }
    
    /**
     * @param parent the parent
     * @param layoutData the LayoutData
     * @return the Add-Button
     */
    private Button createAddButton(Composite parent, GridData layoutData) {
        final Button addButton = new Button(parent, SWT.NONE);
        addButton.setText(Messages.EditParametersDialogAdd);
        addButton.setLayoutData(layoutData);
        addButton.addSelectionListener(new SelectionListener() {
            
            public void widgetSelected(SelectionEvent e) {
                handleSelection(e);
            }

            public void widgetDefaultSelected(SelectionEvent e) {
                handleSelection(e);
            }
            
            /**
             * Handles the selection
             * @param e SelectionEvent
             */
            private void handleSelection(SelectionEvent e) {
                addParameter();
                checkOkButtonEnablement();
            }
        });
        afterAddButtonCreation(addButton);
        return addButton;
    }
    
    /**
     * subclasses may override
     * @param addButton the down button 
     */
    protected void afterAddButtonCreation(Button addButton) {
        // subclasses may override
    }

    /**
     * Adds a new Parameter to the table model
     */
    private void addParameter() {
        String newParamName = DEFAULT_PARAM_NAME;
        boolean unique = true;
        int count = 0;
        do {
            for (Parameter p : m_parameters) {
                unique = true;
                if (p.getName().equals(newParamName)) {
                    unique = false;
                    newParamName = DEFAULT_PARAM_NAME + (++count);
                    break;
                }
            }
        } while (!unique);
        
        final Parameter parameter = new Parameter(newParamName, 
            DEFAULT_PARAM_TYPE);
        m_parameters.add(parameter);
        refreshTable();
        selectRowInParameterTable(-1);
        getParamTableViewer().editElement(parameter, 0);
    }

    /**
     * selects a row in the parameter table and makes sure all listeners are
     * notified (which doesn't happen if you just call Tabke.setSelection()).
     * @param row valid row number or -1 for last row
     */
    private void selectRowInParameterTable(final int row) {
        final boolean selectLast = (row == -1);
        final Table table = getParamTableViewer().getTable();        
        final int tableItemCount = table.getItemCount();
        int index = row;
        
        if (selectLast) {
            index = tableItemCount - 1;
            if (index == -1) { // no entries in table
                return;
            }
        }
        if (index > tableItemCount) { // out of bounds
            return;
        }
        final Object selectedObject = getParamTableViewer().getElementAt(index);
        if (selectedObject != null) {
            getParamTableViewer().setSelection(new StructuredSelection(
                    selectedObject));
        }
    }
    
    /**
     * Removes the current selected Parameter from the table model.
     */
    private void removeSelectedParameter() {
        if (!confirmDeleteParam()) {
            return;
        }
        
        final Table table = getParamTableViewer().getTable();
        final int[] selectionIndices = table.getSelectionIndices();
        for (int index : selectionIndices) {
            m_parameters.remove(index);
        }
        if (selectionIndices.length > 0) {
            int index = selectionIndices[selectionIndices.length - 1];
            refreshTable();
            final int tableItemCount = table.getItemCount();
            if (index >= tableItemCount) {            
                index = -1; // last row     
            }
            selectRowInParameterTable(index);
        }
    }

    /**
     * Creates a Question Dialog for deleting a Parameter
     * @return true if the user clicks OK, false otherwise.
     */
    private boolean confirmDeleteParam() {
        final Dialog dialog = ErrorHandlingUtil.createMessageDialog(
                MessageIDs.Q_CHANGE_INTERFACE_REMOVE_PARAM, null, null,
                getShell());
        return dialog.getReturnCode() == Window.OK;
    }

    /**
     * Creates a Question Dialog for changing a Parameter type.
     * @return true if the user clicks OK, false otherwise.
     */
    private boolean confirmChangeParamType() {
        final Dialog dialog = ErrorHandlingUtil.createMessageDialog(
                MessageIDs.Q_CHANGE_INTERFACE_CHANGE_PARAM_TYPE, null, null,
                getShell());
        return dialog.getReturnCode() == Window.OK;
    }
    
    /**
     * @param parent the parent
     */
    private void createNameField(final Composite parent) {
        final Composite nameFieldArea = new Composite(parent, SWT.NONE);
        final GridLayout areaLayout = new GridLayout(2, false);
        nameFieldArea.setLayout(areaLayout);
        final GridData tableAreaGridData = new GridData();
        tableAreaGridData.horizontalAlignment = GridData.FILL;
        nameFieldArea.setLayoutData(tableAreaGridData);
        final Label nameLabel = new Label(nameFieldArea, SWT.NONE);
        nameLabel.setText(getEditedObjectNameString());
        
        final Label nameField = new Label(nameFieldArea,
                SWT.SINGLE);
        final GridData nameFieldGridData = new GridData();
        nameFieldGridData.grabExcessHorizontalSpace = true;
        nameFieldGridData.horizontalAlignment = GridData.FILL;
        nameField.setLayoutData(nameFieldGridData);
        nameField.setText(getParamInterfaceObj().getName());
    }


    /**
     * @return the name to display for the currently edited object
     */
    protected abstract String getEditedObjectNameString();

    /**
     * @return The Parameters.
     */
    public final List<Parameter> getParameters() {
        return m_parameters;
    }
    
    /**
     * Gets the column index of the given column name.
     * @param columnName a column name.
     * @return the column index of the given column name or -1 if no column
     * with the given name was found.
     */
    private int getColumnIndex(String columnName) {
        int index = 0;
        for (String colName : TABLE_COLUMNS) {
            if (colName.equals(columnName)) {
                return index;
            }
            index++;
        }
        return -1;
    }
    
    /**
     * @param parameter The Parameter object.
     * @param columnIndex the index of the table column.
     * @return the table entry.
     */
    private String getTableCellText(Parameter parameter, int columnIndex) {
        switch (columnIndex) {
            case NAME_TABLE_COLUMN:
                return parameter.getName();
                
            case TYPE_TABLE_COLUMN:
                final String paramType = parameter.getType();
                return CompSystemI18n.getString(paramType, true);

            default:
                StringBuilder msg = new StringBuilder();
                msg.append(Messages.ColumnIndex)
                    .append(StringConstants.SPACE)
                    .append(StringConstants.APOSTROPHE)
                    .append(columnIndex)
                    .append(StringConstants.APOSTROPHE)
                    .append(StringConstants.SPACE)
                    .append(Messages.DoesNotExist)
                    .append(StringConstants.EXCLAMATION_MARK);
                    
                Assert.notReached(msg.toString());
                break;
        }
        return EMPTY_ENTRY;
    }
    
    /**
     * @param value The value to set.
     * @param parameter The Parameter object.
     * @param columnIndex the column index.
     */
    private void setTableCellText(Object value, Parameter parameter, 
        int columnIndex) {
        
        switch (columnIndex) {
            case NAME_TABLE_COLUMN:
                changeParameterName(parameter, (String)value);
                break;
                
            case TYPE_TABLE_COLUMN:
                changeParameterType(parameter, (String)value);
                break;

            default:
                StringBuilder msg = new StringBuilder();
                msg.append(Messages.ColumnIndex)
                    .append(StringConstants.SPACE)
                    .append(StringConstants.APOSTROPHE)
                    .append(columnIndex)
                    .append(StringConstants.APOSTROPHE)
                    .append(StringConstants.SPACE)
                    .append(Messages.DoesNotExist)
                    .append(StringConstants.EXCLAMATION_MARK);
                Assert.notReached(msg.toString());
                break;
        }
        refreshTable();
    }

    /**
     * Changes the Parameter Name.
     * 
     * @param parameter
     *            the Parameter which name is to change.
     * @param name
     *            the new name
     */
    private void changeParameterName(Parameter parameter, String name) {
        if (parameter.getName().equals(name)) {
            return;
        }

        if (isNewParameter(parameter)) {
            parameter.setName(name);
        } else if (confirmChangeParamName()) {
            parameter.setName(name);
        }
    }

    /**
     * optional point to ask the user for permission; subclasses may override
     * 
     * @return true if the param name change is ok
     */
    protected boolean confirmChangeParamName() {
        return true;
    }
    
    /**
     * Changes the Parameter Type.
     * @param parameter the Parameter which type is to change.
     * @param type the type.
     */
    private void changeParameterType(Parameter parameter, String type) {
        if (parameter.getType().equals(type)) {
            return;
        }
        if (isNewParameter(parameter)) {
            parameter.setType(type);
        } else if (confirmChangeParamType()) { // already used Parameter
            final int index = m_parameters.indexOf(parameter);
            final Parameter newParam = new Parameter(parameter.getName(), type);
            m_parameters.remove(parameter);
            m_parameters.add(index, newParam);
        }
    }
    
    /**
     * @param parameter
     *            to check whether it's new
     * @return true if the parameter is a new one
     */
    private boolean isNewParameter(Parameter parameter) {
        return parameter.getGuid() == null;
    }

    /**
     * Refreshes the m_paramTableViewer.
     */
    private void refreshTable() {
        getParamTableViewer().refresh();
        final Table table = getParamTableViewer().getTable();
        table.setFocus();
    }
    
    /**
     * @return the OK-Button of this dialog.
     */
    private Button getOkButton() {
        return getButton(IDialogConstants.OK_ID);
    }

    /**
     * Checks the enablement of the OK-Button
     */
    private void checkOkButtonEnablement() {
        getOkButton().setEnabled(isParamTableValid());
    }
    
    /**
     * @return true if all entries of the parameter table are valid, 
     * false otherwise.
     */
    private boolean isParamTableValid() {
        for (Parameter param : getParameters()) {
            if (EMPTY_ENTRY.equals(param.getName().trim())) {
                setErrorMessage(
                        Messages.EditParametersDialogEmptyParamName);
                return false;
            } else if (EMPTY_ENTRY.equals(param.getType().trim())) {
                setErrorMessage(
                        Messages.EditParametersDialogEmptyParamName);
                return false;
            } else if (isDuplicate(param)) {
                setErrorMessage(
                        NLS.bind(
                                Messages.EditParametersDialogDuplicateParamName,
                                param.getName()));
                return false;
            }
        }

        setErrorMessage(null);
        return true;
    }

    /**
     * 
     * @param parameter A Parameter.
     * @return true if the given Parameter is a duplicate, false otherwise.
     */
    private boolean isDuplicate(Parameter parameter) {
        int occurences = 0;
        for (Parameter param : m_parameters) {
            if (param.getName().equals(parameter.getName())) {
                occurences++;
            }
            if (occurences > 1) {
                return true;
            }
        }
        return false;
    }

    /**
     * Gets all indices of the given Parameter.
     * @param parameter a Parameter
     * @return an Array of indices.
     */
    private Integer[] getIndices(Parameter parameter) {
        final List<Integer> occurenceIndices = new ArrayList<Integer>();
        int index = 0;
        for (Parameter param : m_parameters) {
            if (param.getName().equals(parameter.getName())) {
                occurenceIndices.add(index);
            }
            index++;
        }
        return occurenceIndices.toArray(new Integer[occurenceIndices.size()]);
    }
    
    /**
     * Moves the selected Parameter up or down
     * 
     * @param down
     *            true moves down, false moves up.
     */
    private void moveParameter(boolean down) {
        if (getParamTableViewer().getSelection() 
                instanceof IStructuredSelection) {
            final Parameter param = (Parameter)
                    ((IStructuredSelection)getParamTableViewer()
                            .getSelection()).getFirstElement();
            final int paramIdx = m_parameters.indexOf(param);
            final int newIdxDiff = 1;
            final int newIdx = down ? (paramIdx + newIdxDiff)
                    : (paramIdx - newIdxDiff);
            if (newIdx < m_parameters.size() && newIdx > -1) {
                m_parameters.remove(paramIdx);
                m_parameters.add(newIdx, param);
                refreshTable();
            }
        }
    }

    /**
     * @param paramTableViewer the paramTableViewer to set
     */
    private void setParamTableViewer(TableViewer paramTableViewer) {
        m_paramTableViewer = paramTableViewer;
    }

    /**
     * @return the paramTableViewer
     */
    protected TableViewer getParamTableViewer() {
        return m_paramTableViewer;
    }

    /**
     * @param paramInterfaceObj the paramInterfaceObj to set
     */
    protected void setParamInterfaceObj(
            IParameterInterfacePO paramInterfaceObj) {
        m_paramInterfaceObj = paramInterfaceObj;
    }

    /**
     * @return the paramInterfaceObj
     */
    protected IParameterInterfacePO getParamInterfaceObj() {
        return m_paramInterfaceObj;
    }
}