core/plugins/org.eclipse.dltk.validators.externalchecker/src/org/eclipse/dltk/validators/internal/externalchecker/ui/ExternalCheckerConfigurationPage.java

package org.eclipse.dltk.validators.internal.externalchecker.ui;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.dltk.core.environment.IEnvironment;
import org.eclipse.dltk.core.environment.IFileHandle;
import org.eclipse.dltk.internal.ui.wizards.dialogfields.SelectionButtonDialogField;
import org.eclipse.dltk.internal.ui.wizards.dialogfields.StringDialogField;
import org.eclipse.dltk.ui.environment.EnvironmentPathBlock;
import org.eclipse.dltk.validators.internal.externalchecker.core.ExternalChecker;
import org.eclipse.dltk.validators.internal.externalchecker.core.ExternalCheckerPlugin;
import org.eclipse.dltk.validators.internal.externalchecker.core.Rule;
import org.eclipse.dltk.validators.ui.ValidatorConfigurationPage;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ComboBoxCellEditor;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.Text;

public class ExternalCheckerConfigurationPage extends ValidatorConfigurationPage {

	private StringDialogField fArguments;
	private EnvironmentPathBlock fPath;
	private StringDialogField fExtensions;
	private SelectionButtonDialogField fPassInterpreterEnvironmentVars;

	private Table fTable;
	private TableViewer tableViewer;
	private Button addRule;
	private Button delRule;
	private RulesList rulesList = new RulesList();

	private String message = ""; //$NON-NLS-1$
	private int messageType = IStatus.OK;

	private final String TYPES = "TYPES"; //$NON-NLS-1$

	public RulesList getRulesList() {
		return rulesList;
	}

	private String[] columnNames = new String[] { "RULES", "TYPES" }; //$NON-NLS-1$ //$NON-NLS-2$

	public ExternalCheckerConfigurationPage() {
	}

	@Override
	public IStatus getStatus() {
		return new Status(messageType, ExternalCheckerPlugin.PLUGIN_ID, message);
	}

	private void resetMessage() {
		this.message = ""; //$NON-NLS-1$
		this.messageType = IStatus.OK;
	}

	private void setMessage(IEnvironment env, String message, int type) {
		String pattern = Messages.ValidatorMessages_path_msgPattern;
		message = NLS.bind(pattern, new String[] { env.getName(), message });
		setMessage(message, type);
	}

	private void setMessage(String message, int type) {
		if (type > messageType) {
			this.message = message;
			this.messageType = type;
		}
	}

	protected void validateTclCheckerPath() {
		Map<IEnvironment, String> envs = fPath.getPaths();
		for (Iterator<IEnvironment> it = envs.keySet().iterator(); it.hasNext();) {
			IEnvironment env = it.next();
			String txtPath = envs.get(env).toString();
			txtPath = txtPath.trim();

			if ("".equals(txtPath)) { //$NON-NLS-1$
				/*
				 * setMessage(env,
				 * ValidatorMessages.ValidatorMessages_path_isempty,
				 * IStatus.INFO);
				 */
				continue;
			}

			IPath path = Path.fromPortableString(txtPath);
			IFileHandle file = env.getFile(path);

			if (file == null) {
				setMessage(env, Messages.ValidatorMessages_path_isinvalid, IStatus.ERROR);
				continue;
			} else if (!file.isFile()) {
				setMessage(env, Messages.ValidatorMessages_path_notexists, IStatus.ERROR);
				continue;
			} else if (!file.exists()) {
				setMessage(env, Messages.ValidatorMessages_path_notexists, IStatus.ERROR);
				continue;
			}
		}
	}

	protected void validate() {
		resetMessage();
		validateTclCheckerPath();
		updateStatus();
	}

	@Override
	public void applyChanges() {
		ExternalChecker externalChecker = getExtrenalChecker();
		externalChecker.setArguments(this.fArguments.getText());
		externalChecker.setCommand(this.fPath.getPaths());
		externalChecker.setRules(rulesList.getRules());
		externalChecker.setExtensions(this.fExtensions.getText());
		externalChecker.setPassInterpreterEnvironmentVars(this.fPassInterpreterEnvironmentVars.isSelected());
	}

	private void createPathBrowse(final Composite parent, int columns) {
		this.fPath = new EnvironmentPathBlock();
		this.fPath.createControl(parent, columns);
		fPath.addListener(paths -> validate());
	}

	@Override
	public void createControl(final Composite ancestor, int columns) {
		createFields();

		this.createPathBrowse(ancestor, columns);
		this.fArguments.doFillIntoGrid(ancestor, columns);
		this.fExtensions.doFillIntoGrid(ancestor, columns);
		this.fPassInterpreterEnvironmentVars.doFillIntoGrid(ancestor, columns);

		Label label = new Label(ancestor, SWT.WRAP);
		label.setText(Messages.ExternalCheckerConfigurationPage_commaSeparatedListOfExtensions);
		GridData data = new GridData(SWT.FILL, SWT.FILL, false, false);
		data.horizontalSpan = columns;
		data.minimumWidth = 100;
		data.widthHint = 100;
		label.setLayoutData(data);
		this.rulesList.getRules().clear();

		// GridLayout layout = (GridLayout)ancestor.getLayout();

		Group group = new Group(ancestor, SWT.NONE);
		group.setText(Messages.ExternalCheckerConfigurationPage_patternRules);
		data = new GridData(SWT.FILL, SWT.FILL, true, true);
		data.horizontalSpan = columns;
		group.setLayoutData(data);
		GridLayout layout = new GridLayout(2, false);
		group.setLayout(layout);

		label = new Label(ancestor, SWT.WRAP);
		label.setText(Messages.ExternalCheckerConfigurationPage_patternIsARegularExpression);
		data = new GridData(SWT.FILL, SWT.FILL, false, false);
		data.horizontalSpan = columns;
		data.minimumWidth = 100;
		data.widthHint = 100;
		label.setLayoutData(data);
		// label.
		// label.setSize(label.computeSize(100, SWT.DEFAULT));

		fTable = new Table(group,
				SWT.SINGLE | SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.HIDE_SELECTION);
		data = new GridData(SWT.FILL, SWT.FILL, true, true);
		data.widthHint = 300;
		data.heightHint = 100;
		fTable.setLayoutData(data);

		// fTable.setLayout(layout);
		fTable.setLinesVisible(true);
		fTable.setHeaderVisible(true);
		// fTable.setSize(500, 500);

		TableColumn col1 = new TableColumn(fTable, SWT.LEFT, 0);
		col1.setWidth(200);
		col1.setText(Messages.ExternalCheckerConfigurationPage_outputRule);

		TableColumn col2 = new TableColumn(fTable, SWT.LEFT, 1);
		col2.setWidth(100);
		col2.setText(Messages.ExternalCheckerConfigurationPage_type);

		tableViewer = new TableViewer(fTable);
		tableViewer.setColumnProperties(columnNames);
		CellEditor[] editors = new CellEditor[columnNames.length];

		TextCellEditor textEditor = new TextCellEditor(fTable);
		((Text) textEditor.getControl()).setTextLimit(60);
		editors[0] = textEditor;

		ComboBoxCellEditor comboEditor = new ComboBoxCellEditor(fTable, rulesList.getTypes(), SWT.READ_ONLY);
		editors[1] = comboEditor;

		tableViewer.setCellEditors(editors);

		tableViewer.setCellModifier(new RuleCelllModifier(this));

		tableViewer.setContentProvider(new RulesContentProvider());
		tableViewer.setLabelProvider(new RulesLabelProvider());
		tableViewer.setInput(rulesList);

		Composite buttons = new Composite(group, SWT.NONE);
		buttons.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING));
		layout = new GridLayout();
		layout.marginHeight = 0;
		layout.marginWidth = 0;
		buttons.setLayout(layout);
		data = new GridData(SWT.FILL, SWT.NONE, false, false);
		data.verticalAlignment = SWT.TOP;
		addRule = new Button(buttons, SWT.PUSH);
		addRule.setLayoutData(data);
		addRule.setText(Messages.ExternalCheckerConfigurationPage_addRule);
		addRule.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent ev) {
				rulesList.addRule();
			}
		});

		delRule = new Button(buttons, SWT.PUSH);
		delRule.setLayoutData(data);
		delRule.setText(Messages.ExternalCheckerConfigurationPage_deleteRule);
		delRule.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent ev) {
				Rule rule = (Rule) ((IStructuredSelection) tableViewer.getSelection()).getFirstElement();
				if (rule != null)
					rulesList.removeRule(rule);
			}
		});

		updateValuesFrom();
	}

	private ExternalChecker getExtrenalChecker() {
		return (ExternalChecker) getValidator();

	}

	private void updateValuesFrom() {
		ExternalChecker externalChecker = getExtrenalChecker();
		this.fArguments.setText(externalChecker.getArguments());

		this.fPath.setPaths(externalChecker.getCommand());
		this.fExtensions.setText(externalChecker.getExtensions());
		this.fPassInterpreterEnvironmentVars.setSelection(externalChecker.isPassInterpreterEnvironmentVars());

		this.rulesList.getRules().clear();
		for (int i = 0; i < externalChecker.getNRules(); i++) {
			Rule r = externalChecker.getRule(i);
			rulesList.addRule(r);
		}
	}

	private void createFields() {
		this.fArguments = new StringDialogField();
		this.fArguments.setLabelText(Messages.ExternalCheckerConfigurationPage_CheckerArguments);
		this.fExtensions = new StringDialogField();
		this.fExtensions.setLabelText(Messages.ExternalCheckerConfigurationPage_filenameExtensions);
		this.fPassInterpreterEnvironmentVars = new SelectionButtonDialogField(SWT.CHECK);
		this.fPassInterpreterEnvironmentVars
				.setLabelText(Messages.ExternalCheckerConfigurationPage_passInterpreterEnvironmentVariables);
	}

	public class RulesContentProvider implements IStructuredContentProvider, IRulesListViewer {

		@Override
		public Object[] getElements(Object inputElement) {
			return rulesList.getRules().toArray();
		}

		@Override
		public void dispose() {
			rulesList.removeChangeListener(this);
		}

		@Override
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			if (newInput != null)
				((RulesList) newInput).addChangeListener(this);
			if (oldInput != null)
				((RulesList) oldInput).removeChangeListener(this);
		}

		@Override
		public void addRule(Rule r) {
			tableViewer.add(r);
			tableViewer.editElement(r, 0);
		}

		@Override
		public void removeRule(Rule r) {
			tableViewer.remove(r);
		}

		@Override
		public void updateRule(Rule r) {
			tableViewer.update(r, null);
		}

	}

	public List<String> getColumnNames() {
		return Arrays.asList(columnNames);
	}

	public String[] getChoices(String property) {
		if (TYPES.equals(property)) {
			return rulesList.getTypes();
		}
		return new String[0];
	}
}