| /******************************************************************************* |
| * Copyright (c) 2001, 2007 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.wst.validation.internal.ui; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.logging.Level; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.jem.util.logger.LogEntry; |
| import org.eclipse.jem.util.logger.proxy.Logger; |
| import org.eclipse.jface.preference.PreferencePage; |
| import org.eclipse.jface.viewers.ColumnWeightData; |
| import org.eclipse.jface.viewers.IStructuredContentProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.ITableLabelProvider; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.viewers.TableLayout; |
| import org.eclipse.jface.viewers.TableViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.jface.viewers.ViewerSorter; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.ScrolledComposite; |
| import org.eclipse.swt.events.FocusAdapter; |
| import org.eclipse.swt.events.FocusEvent; |
| import org.eclipse.swt.events.MenuAdapter; |
| import org.eclipse.swt.events.MenuEvent; |
| import org.eclipse.swt.events.MouseAdapter; |
| import org.eclipse.swt.events.MouseEvent; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.Rectangle; |
| 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.Display; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.MenuItem; |
| import org.eclipse.swt.widgets.MessageBox; |
| 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.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchPreferencePage; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.wst.common.frameworks.internal.ui.WTPUIPlugin; |
| import org.eclipse.wst.validation.internal.ConfigurationManager; |
| import org.eclipse.wst.validation.internal.GlobalConfiguration; |
| import org.eclipse.wst.validation.internal.ProjectConfiguration; |
| import org.eclipse.wst.validation.internal.ValidatorMetaData; |
| import org.eclipse.wst.validation.internal.operations.ValidatorManager; |
| import org.eclipse.wst.validation.internal.ui.plugin.ValidationUIPlugin; |
| |
| /** |
| * This class and its inner classes are not intended to be subclassed outside of the validation |
| * framework. |
| */ |
| public class ValidationPreferencePage extends PreferencePage implements IWorkbenchPreferencePage { |
| private IValidationPage _pageImpl = null; |
| |
| /** |
| * Initially, this interface was created as an abstract class, and getControl() was implemented. |
| * (getProject() could also have been implemented in the abstract class.) However, at runtime, a |
| * NullPointerException was thrown; the inner class had lost its pointer to its enclosing class. |
| * After some experimentation, I discovered that if I changed the parent to an interface, the |
| * enclosing class could be found. (Merely moving the AValidationPage into its own file was |
| * insufficient.) |
| */ |
| public interface IValidationPage { |
| public Composite createPage(Composite parent) throws InvocationTargetException; |
| |
| public boolean performOk() throws InvocationTargetException; |
| |
| public boolean performDefaults() throws InvocationTargetException; |
| |
| public Composite getControl(); |
| |
| public void dispose(); |
| |
| public void loseFocus(); // Page is losing focus (event notification) |
| |
| public void gainFocus(); // Page is gaining focus (event notification) |
| } |
| |
| public class InvalidPage implements IValidationPage { |
| private Composite page = null; |
| |
| private Composite composite = null; |
| private GridLayout layout = null; |
| private Label messageLabel = null; |
| |
| public InvalidPage(Composite parent) { |
| page = createPage(parent); |
| } |
| |
| /** |
| * This page is added to the Properties guide if some internal problem occurred; for |
| * example, the highlighted item in the workbench is not an IProject (according to this |
| * page's plugin.xml, this page is only valid when an IProject is selected). |
| */ |
| public Composite createPage(Composite parent) { |
| // Don't create the default and apply buttons. |
| noDefaultAndApplyButton(); |
| |
| final ScrolledComposite sc1 = new ScrolledComposite(parent, SWT.H_SCROLL | SWT.V_SCROLL); |
| sc1.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| composite = new Composite(sc1, SWT.NONE); |
| sc1.setContent(composite); |
| layout = new GridLayout(); |
| composite.setLayout(layout); |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(composite, ContextIds.VALIDATION_PROPERTIES_PAGE); |
| |
| messageLabel = new Label(composite, SWT.NONE); |
| messageLabel.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INVALID_REGISTER)); |
| |
| composite.setSize(composite.computeSize(SWT.DEFAULT, SWT.DEFAULT)); |
| |
| return composite; |
| } |
| |
| public boolean performDefaults() { |
| return true; |
| } |
| |
| /** |
| * Since this page occurs under invalid circumstances, there is nothing to save. |
| */ |
| public boolean performOk() { |
| return true; |
| } |
| |
| public Composite getControl() { |
| return page; |
| } |
| |
| public void dispose() { |
| messageLabel.dispose(); |
| // layout.dispose(); |
| composite.dispose(); |
| } |
| |
| public void loseFocus() { |
| // This page does not depend on the contents of any other page in the wizard, so do |
| // nothing. |
| } |
| |
| public void gainFocus() { |
| // This page does not depend on the contents of any other page in the wizard, so do |
| // nothing. |
| } |
| } |
| |
| private class NoValidatorsPage implements IValidationPage { |
| private Composite page = null; |
| private Composite composite = null; |
| private GridLayout layout = null; |
| private GridData data = null; |
| private Label messageLabel = null; |
| |
| public NoValidatorsPage(Composite parent) { |
| page = createPage(parent); |
| } |
| |
| /** |
| * This page is created if an IProject is selected, but that project has no validators |
| * configured (i.e., the page is valid, but an empty list.) |
| */ |
| public Composite createPage(Composite parent) { |
| // Don't create the default and apply buttons. |
| noDefaultAndApplyButton(); |
| |
| // top level group |
| final ScrolledComposite sc1 = new ScrolledComposite(parent, SWT.H_SCROLL | SWT.V_SCROLL); |
| sc1.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| composite = new Composite(sc1, SWT.NONE); |
| sc1.setContent(composite); |
| layout = new GridLayout(); |
| composite.setLayout(layout); |
| data = new GridData(GridData.VERTICAL_ALIGN_FILL | GridData.HORIZONTAL_ALIGN_FILL); |
| composite.setLayoutData(data); |
| |
| messageLabel = new Label(composite, SWT.NONE); |
| messageLabel.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_UI_NO_VALIDATORS_INSTALLED)); |
| |
| composite.setSize(composite.computeSize(SWT.DEFAULT, SWT.DEFAULT)); |
| |
| return composite; |
| } |
| |
| |
| /** |
| * Since there are no validators, there is nothing to save. |
| */ |
| public boolean performOk() { |
| return true; |
| } |
| |
| public boolean performDefaults() { |
| return true; |
| } |
| |
| public Composite getControl() { |
| return page; |
| } |
| |
| public void dispose() { |
| messageLabel.dispose(); |
| // layout.dispose(); |
| // data.dispose(); |
| composite.dispose(); |
| } |
| |
| public void loseFocus() { |
| // This page does not depend on the contents of any other page in the wizard, so do |
| // nothing. |
| } |
| |
| public void gainFocus() { |
| // This page does not depend on the contents of any other page in the wizard, so do |
| // nothing. |
| } |
| } |
| |
| private class ValidatorListPage implements IValidationPage { |
| private Composite page = null; |
| |
| private Composite composite = null; |
| TableViewer validatorList = null; |
| private Button enableAllButton = null; |
| private Button disableAllButton = null; |
| private Label emptyRowPlaceholder = null; |
| Button disableAllValidation = null; |
| Button overrideButton = null; |
| Button saveButton = null; |
| private Label listLabel = null; |
| private Table validatorsTable; |
| |
| GlobalConfiguration pagePreferences = null; // the values currently on the page, but not |
| // necessarily stored yet. Package visibility |
| // for the widget listeners (the compiler would |
| // have to create a synthetic accessor method in |
| // order to access this field) |
| //private boolean _isAutoBuildEnabled; // initialized in the constructor |
| private ValidatorMetaData[] _oldVmd = null; // Cache the enabled validators so that, if |
| private Map _oldDelegates = null; // Cache the validator delegates. |
| // there is no change to this list, the |
| // expensive task list update can be avoided |
| private boolean _allow = false; // Cache the value of the prefence "allow projects to |
| |
| // override" so that, when OK is clicked, we can determine |
| // if "allow" has changed or not. |
| |
| /** |
| * This class is provided for the CheckboxTableViewer in the |
| * ValidationPropertiesPage$ValidatorListPage class. |
| */ |
| public class ValidationContentProvider implements IStructuredContentProvider { |
| /** |
| * Disposes of this content provider. This is called by the viewer when it is disposed. |
| */ |
| public void dispose() { |
| //dispose |
| } |
| |
| /** |
| * Returns the elements to display in the viewer when its input is set to the given |
| * element. These elements can be presented as rows in a table, items in a list, etc. |
| * The result is not modified by the viewer. |
| * |
| * @param inputElement |
| * the input element |
| * @return the array of elements to display in the viewer |
| */ |
| public java.lang.Object[] getElements(Object inputElement) { |
| if (inputElement instanceof ValidatorMetaData[]) { |
| // The Collection is the Collection which is returned by ValidatorManager's |
| // getConfiguredValidatorMetaData(IProject) call. |
| // This Collection is set to be the input of the CheckboxTableViewer in |
| // ValidationPropertiesPage$ValidatorListPage's createPage(Composite) |
| // method. |
| return (ValidatorMetaData[]) inputElement; |
| } |
| return new Object[0]; |
| } |
| |
| /** |
| * Notifies this content provider that the given viewer's input has been switched to a |
| * different element. |
| * <p> |
| * A typical use for this method is registering the content provider as a listener to |
| * changes on the new input (using model-specific means), and deregistering the viewer |
| * from the old input. In response to these change notifications, the content provider |
| * propagates the changes to the viewer. |
| * </p> |
| * |
| * @param viewer |
| * the viewer |
| * @param oldInput |
| * the old input element, or <code>null</code> if the viewer did not |
| * previously have an input |
| * @param newInput |
| * the new input element, or <code>null</code> if the viewer does not have |
| * an input |
| */ |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { |
| //do nothing |
| } |
| |
| |
| |
| } |
| |
| /** |
| * This class is provided for ValidationPropertiesPage$ValidatorListPage's |
| * checkboxTableViewer element. |
| */ |
| public class ValidationLabelProvider extends LabelProvider implements ITableLabelProvider { |
| /** |
| * Override the LabelProvider's text, by customizing the text for a ValidatorMetaData |
| * element. |
| */ |
| public String getText(Object element) { |
| if (element == null) { |
| return ""; //$NON-NLS-1$ |
| } else if (element instanceof ValidatorMetaData) { |
| return ((ValidatorMetaData) element).getValidatorDisplayName(); |
| } else { |
| return super.getText(element); |
| } |
| } |
| |
| private Image getImage(String imageName) { |
| boolean isDisabled = !validatorsTable.isEnabled(); |
| if (isDisabled) { |
| imageName = imageName + "_disabled"; //$NON-NLS-N$ |
| } |
| Image image = ValidationUIPlugin.getPlugin().getImage(imageName); |
| return image; |
| } |
| |
| public Image getColumnImage(Object element, int columnIndex) { |
| if(columnIndex == 1) { |
| if(((ValidatorMetaData)element).isManualValidation()) |
| return getImage("ok_tbl"); |
| return getImage("fail_tbl"); |
| } |
| else if(columnIndex == 2) { |
| if(((ValidatorMetaData)element).isBuildValidation()) |
| return getImage("ok_tbl");; |
| return getImage("fail_tbl"); |
| } |
| else if (columnIndex == 3) |
| { |
| ValidatorMetaData vmd = (ValidatorMetaData)element; |
| |
| if (vmd.isDelegating()) |
| { |
| return getImage("settings"); |
| } |
| } |
| return null; |
| |
| } |
| |
| public String getColumnText(Object element, int columnIndex) { |
| if(columnIndex == 0) { |
| return ((ValidatorMetaData) element).getValidatorDisplayName(); |
| } |
| /*if(columnIndex == 1) { |
| if(((ValidatorMetaData)element).isManualValidation()) |
| return COMBO_VALUES[0]; |
| return COMBO_VALUES[1]; |
| } else if(columnIndex == 2) { |
| if(((ValidatorMetaData)element).isBuildValidation()) |
| return COMBO_VALUES[0]; |
| return COMBO_VALUES[1]; |
| }*/ |
| return null; |
| } |
| } |
| |
| /** |
| * This class is used to sort the CheckboxTableViewer elements. |
| */ |
| public class ValidationViewerSorter extends ViewerSorter { |
| /** |
| * Returns a negative, zero, or positive number depending on whether the first element |
| * is less than, equal to, or greater than the second element. |
| * <p> |
| * The default implementation of this method is based on comparing the elements' |
| * categories as computed by the <code>category</code> framework method. Elements |
| * within the same category are further subjected to a case insensitive compare of their |
| * label strings, either as computed by the content viewer's label provider, or their |
| * <code>toString</code> values in other cases. Subclasses may override. |
| * </p> |
| * |
| * @param viewer |
| * the viewer |
| * @param e1 |
| * the first element |
| * @param e2 |
| * the second element |
| * @return a negative number if the first element is less than the second element; the |
| * value <code>0</code> if the first element is equal to the second element; |
| * and a positive number if the first element is greater than the second element |
| */ |
| public int compare(Viewer viewer, Object e1, Object e2) { |
| // Can't instantiate ViewerSorter because it's abstract, so use this |
| // inner class to represent it. |
| return super.compare(viewer, e1, e2); |
| } |
| } |
| |
| public ValidatorListPage(Composite parent) throws InvocationTargetException { |
| //_isAutoBuildEnabled = ValidatorManager.getManager().isGlobalAutoBuildEnabled(); |
| pagePreferences = new GlobalConfiguration(ConfigurationManager.getManager().getGlobalConfiguration()); // This |
| // represents the values on the page that haven't been persistedyet. |
| // Start with the last values that were persisted into the current page's starting values. |
| |
| _oldVmd = pagePreferences.getEnabledValidators(); // Cache the enabled validators so |
| // that, if there is no change to this |
| // list, the expensive task list |
| // update can be avoided |
| |
| _oldDelegates = new HashMap(pagePreferences.getDelegatingValidators()); |
| |
| _allow = pagePreferences.canProjectsOverride(); |
| |
| page = createPage(parent); |
| } |
| |
| private void setupTableColumns(Table table, TableViewer viewer) { |
| TableColumn validatorColumn = new TableColumn(table, SWT.NONE); |
| validatorColumn.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.VALIDATOR)); |
| validatorColumn.setResizable(false); |
| validatorColumn.setWidth(320); |
| TableColumn manualColumn = new TableColumn(table, SWT.NONE); |
| manualColumn.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.MANUAL)); |
| manualColumn.setResizable(false); |
| manualColumn.setWidth(40); |
| TableColumn buildColumn = new TableColumn(table, SWT.NONE); |
| buildColumn.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.BUILD)); |
| buildColumn.setResizable(false); |
| buildColumn.setWidth(40); |
| TableColumn settingsColumn = new TableColumn(table, SWT.NONE); |
| settingsColumn.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.SETTINGS)); |
| settingsColumn.setResizable(false); |
| settingsColumn.setWidth(50); |
| } |
| |
| public Composite createPage(Composite parent) throws InvocationTargetException { |
| // top level group |
| final ScrolledComposite sc1 = new ScrolledComposite(parent, SWT.H_SCROLL | SWT.V_SCROLL); |
| sc1.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| composite = new Composite(sc1, SWT.NONE); |
| sc1.setContent(composite); |
| composite.setLayout(new GridLayout()); // use the layout's default preferences |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(composite, ContextIds.VALIDATION_PREFERENCE_PAGE); |
| |
| Composite validatorGroup = new Composite(composite, SWT.NONE); |
| |
| |
| GridLayout validatorGroupLayout = new GridLayout(); |
| validatorGroupLayout.numColumns = 2; |
| validatorGroup.setLayout(validatorGroupLayout); |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(validatorGroup, ContextIds.VALIDATION_PREFERENCE_PAGE); |
| |
| GridData overrideData = new GridData(GridData.FILL_HORIZONTAL); |
| emptyRowPlaceholder = new Label(validatorGroup, SWT.NONE); |
| emptyRowPlaceholder.setLayoutData(new GridData()); |
| emptyRowPlaceholder = new Label(validatorGroup, SWT.NONE); |
| emptyRowPlaceholder.setLayoutData(new GridData()); |
| |
| overrideData.horizontalSpan = 2; |
| overrideButton = new Button(validatorGroup, SWT.CHECK); |
| overrideButton.setLayoutData(overrideData); |
| overrideButton.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.PREF_BUTTON_OVERRIDE)); |
| overrideButton.setEnabled(true); |
| overrideButton.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| pagePreferences.setCanProjectsOverride(overrideButton.getSelection()); |
| try { |
| updateWidgets(); |
| } catch (InvocationTargetException exc) { |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } |
| } |
| }); |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(overrideButton, ContextIds.VALIDATION_PREFERENCE_PAGE_OVERRIDE); |
| |
| emptyRowPlaceholder = new Label(validatorGroup, SWT.NONE); |
| emptyRowPlaceholder.setLayoutData(new GridData()); |
| |
| GridData disableValidationData = new GridData(GridData.FILL_HORIZONTAL); |
| disableValidationData.horizontalSpan = 2; |
| disableAllValidation = new Button(validatorGroup, SWT.CHECK); |
| disableAllValidation.setLayoutData(disableValidationData); |
| disableAllValidation.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.DISABLE_VALIDATION)); |
| disableAllValidation.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| pagePreferences.setDisableAllValidation(disableAllValidation.getSelection()); |
| disableAllValidation.setFocus(); |
| validatorsTable.setEnabled(!disableAllValidation.getSelection()); |
| enableAllButton.setEnabled(!disableAllValidation.getSelection()); |
| disableAllButton.setEnabled(!disableAllValidation.getSelection()); |
| validatorList.refresh(); |
| } |
| }); |
| |
| emptyRowPlaceholder = new Label(validatorGroup, SWT.NONE); |
| emptyRowPlaceholder.setLayoutData(new GridData()); |
| |
| GridData saveFileData = new GridData(GridData.FILL_HORIZONTAL); |
| saveFileData.horizontalSpan = 2; |
| saveButton = new Button(validatorGroup, SWT.CHECK); |
| saveButton.setLayoutData(saveFileData); |
| saveButton.setText(ValidationUIMessages.PrefPage_always_save); |
| saveButton.setSelection(pagePreferences.getSaveAutomatically()); |
| saveButton.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| pagePreferences.setSaveAutomatically(saveButton.getSelection()); |
| saveButton.setFocus(); |
| } |
| }); |
| |
| emptyRowPlaceholder = new Label(validatorGroup, SWT.NONE); |
| emptyRowPlaceholder.setLayoutData(new GridData()); |
| |
| listLabel = new Label(validatorGroup, SWT.NONE); |
| GridData listLabelData = new GridData(GridData.FILL_HORIZONTAL); |
| listLabelData.horizontalSpan = 2; |
| listLabel.setLayoutData(listLabelData); |
| listLabel.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.PREF_VALLIST_TITLE)); |
| |
| validatorsTable = new Table(validatorGroup,SWT.BORDER | SWT.FULL_SELECTION); |
| TableLayout tableLayout = new TableLayout(); |
| tableLayout.addColumnData(new ColumnWeightData(160, true)); |
| tableLayout.addColumnData(new ColumnWeightData(40, true)); |
| tableLayout.addColumnData(new ColumnWeightData(30, true)); |
| tableLayout.addColumnData(new ColumnWeightData(40, true)); |
| |
| validatorsTable.setHeaderVisible(true); |
| validatorsTable.setLinesVisible(true); |
| validatorsTable.setLayout(tableLayout); |
| |
| validatorList = new TableViewer(validatorsTable); |
| GridData validatorListData = new GridData(GridData.FILL_HORIZONTAL); |
| validatorListData.horizontalSpan = 2; |
| validatorsTable.setLayoutData(validatorListData); |
| validatorList.getTable().setLayoutData(validatorListData); |
| validatorList.setLabelProvider(new ValidationLabelProvider()); |
| validatorList.setContentProvider(new ValidationContentProvider()); |
| validatorList.setSorter(new ValidationViewerSorter()); |
| setupTableColumns(validatorsTable,validatorList); |
| validatorList.setInput(pagePreferences.getValidators()); |
| validatorsTable.addMouseListener(new MouseAdapter() { |
| |
| public void mouseDown(MouseEvent e) |
| { |
| if (e.button != 1) |
| { |
| return; |
| } |
| |
| TableItem tableItem = validatorsTable.getItem(new Point(e.x, e.y)); |
| if (tableItem == null || tableItem.isDisposed()) |
| { |
| // item no longer exists |
| return; |
| } |
| int columnNumber; |
| int columnsCount = validatorsTable.getColumnCount(); |
| if (columnsCount == 0) |
| { |
| // If no TableColumn, Table acts as if it has a single column |
| // which takes the whole width. |
| columnNumber = 0; |
| } |
| else |
| { |
| columnNumber = -1; |
| for (int i = 0; i < columnsCount; i++) |
| { |
| Rectangle bounds = tableItem.getBounds(i); |
| if (bounds.contains(e.x, e.y)) |
| { |
| columnNumber = i; |
| break; |
| } |
| } |
| if (columnNumber == -1) |
| { |
| return; |
| } |
| } |
| |
| columnClicked(columnNumber); |
| }}); |
| |
| |
| |
| validatorsTable.setMenu(createContextMenu()); |
| validatorsTable.addFocusListener(new FocusAdapter(){ |
| |
| public void focusGained(FocusEvent e) |
| { |
| super.focusGained(e); |
| if (validatorsTable.getSelectionCount() == 0) |
| { |
| validatorsTable.select(0); |
| } |
| }}); |
| |
| enableAllButton = new Button(validatorGroup, SWT.PUSH); |
| enableAllButton.setLayoutData(new GridData()); |
| enableAllButton.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.PREF_BUTTON_ENABLEALL)); |
| enableAllButton.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| try { |
| performEnableAll(); |
| } catch (InvocationTargetException exc) { |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } |
| } |
| }); |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(enableAllButton, ContextIds.VALIDATION_PREFERENCE_PAGE); |
| |
| disableAllButton = new Button(validatorGroup, SWT.PUSH); |
| disableAllButton.setLayoutData(new GridData()); |
| disableAllButton.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.PREF_BUTTON_DISABLEALL)); |
| disableAllButton.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| try { |
| performDisableAll(); |
| } catch (InvocationTargetException exc) { |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } |
| } |
| }); |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(disableAllButton, ContextIds.VALIDATION_PREFERENCE_PAGE); |
| |
| Composite buttonGroup = new Composite(composite, SWT.NONE); |
| GridLayout buttonGroupLayout = new GridLayout(); |
| buttonGroupLayout.numColumns = 2; |
| buttonGroup.setLayout(buttonGroupLayout); |
| buttonGroup.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL)); |
| // Have to set the tab order or only the first checkbox in a Composite can |
| // be tab-ed to. (Seems to apply only to checkboxes. Have to use the arrow |
| // key to navigate the checkboxes.) |
| validatorGroup.setTabList(new Control[]{overrideButton, disableAllValidation, saveButton, validatorList.getTable(), enableAllButton, disableAllButton}); |
| |
| updateWidgets(); |
| |
| applyDialogFont(composite); |
| composite.setSize(composite.computeSize(SWT.DEFAULT, SWT.DEFAULT)); |
| |
| return composite; |
| } |
| |
| protected Menu createContextMenu() |
| { |
| final Menu menu = new Menu(validatorsTable.getShell(), SWT.POP_UP); |
| final MenuItem manualItem = new MenuItem (menu, SWT.CHECK); |
| manualItem.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.PREF_MNU_MANUAL)); |
| final MenuItem buildItem = new MenuItem (menu, SWT.CHECK); |
| buildItem.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.PREF_MNU_BUILD)); |
| final MenuItem settingsItem = new MenuItem (menu, SWT.PUSH); |
| settingsItem.setText(ResourceHandler.getExternalizedMessage(ResourceConstants.PREF_MNU_SETTINGS)); |
| |
| class MenuItemListener extends SelectionAdapter |
| { |
| public void widgetSelected(SelectionEvent e) |
| { |
| MenuItem menuItem = (MenuItem) e.getSource(); |
| int index = menu.indexOf(menuItem) + 1; |
| columnClicked(index); |
| } |
| } |
| MenuItemListener listener = new MenuItemListener(); |
| manualItem.addSelectionListener(listener); |
| buildItem.addSelectionListener(listener); |
| settingsItem.addSelectionListener(listener); |
| |
| menu.addMenuListener(new MenuAdapter() { |
| public void menuShown(MenuEvent e) |
| { |
| IStructuredSelection selection = (IStructuredSelection) validatorList.getSelection(); |
| ValidatorMetaData vmd = (ValidatorMetaData) selection.getFirstElement(); |
| manualItem.setSelection(vmd.isManualValidation()); |
| buildItem.setSelection(vmd.isBuildValidation()); |
| settingsItem.setEnabled(vmd.isDelegating()); |
| }}); |
| |
| return menu; |
| } |
| |
| protected void columnClicked(int columnToEdit) |
| { |
| IStructuredSelection selection = (IStructuredSelection) validatorList.getSelection(); |
| ValidatorMetaData vmd = (ValidatorMetaData) selection.getFirstElement(); |
| |
| switch (columnToEdit) |
| { |
| case 1: |
| vmd.setManualValidation(!vmd.isManualValidation()); |
| break; |
| case 2: |
| vmd.setBuildValidation(!vmd.isBuildValidation()); |
| break; |
| case 3: |
| { |
| if (!vmd.isDelegating()) { |
| break; |
| } |
| |
| String delegateID = pagePreferences.getDelegateUniqueName(vmd); |
| |
| Shell shell = Display.getCurrent().getActiveShell(); |
| DelegatingValidatorPreferencesDialog dialog = new DelegatingValidatorPreferencesDialog(shell, vmd, delegateID); |
| |
| dialog.setBlockOnOpen(true); |
| dialog.create(); |
| |
| int result = dialog.open(); |
| |
| if (result == Window.OK) |
| { |
| pagePreferences.setDelegateUniqueName(vmd, dialog.getDelegateID()); |
| } |
| } |
| break; |
| default: |
| break; |
| } |
| validatorList.refresh(); |
| } |
| |
| protected void updateWidgets() throws InvocationTargetException { |
| // Need to update even the widgets that do not change based on another |
| // widgets because of performDefaults(). If performDefaults() is selected, |
| // then the pagePreferences values are reset, and these widgets |
| // might also need to be updated. |
| updateTable(); |
| updateAllWidgets(); |
| updateHelp(); |
| } |
| |
| protected void updateWidgetsForDefaults() throws InvocationTargetException { |
| updateTableForDefaults(); |
| updateAllWidgets(); |
| updateHelp(); |
| } |
| |
| /** |
| * @throws InvocationTargetException |
| */ |
| private void updateAllWidgets() throws InvocationTargetException { |
| overrideButton.setSelection(pagePreferences.canProjectsOverride()); |
| disableAllValidation.setSelection(pagePreferences.isDisableAllValidation()); |
| validatorsTable.setEnabled(!disableAllValidation.getSelection()); |
| enableAllButton.setEnabled(!disableAllValidation.getSelection()); |
| disableAllButton.setEnabled(!disableAllValidation.getSelection()); |
| } |
| |
| protected void updateTable() throws InvocationTargetException { |
| TableItem[] items = validatorsTable.getItems(); |
| for (int i = 0; i < items.length; i++) { |
| TableItem item = items[i]; |
| ValidatorMetaData vmd = (ValidatorMetaData) item.getData(); |
| |
| // Should the validator be enabled? Read the user's preferences from last time, |
| // if they exist, and set from that. If they don't exist, use the Validator class' |
| // default value. |
| if (pagePreferences.isManualEnabled(vmd)) |
| vmd.setManualValidation(true); |
| else |
| vmd.setManualValidation(false); |
| if (pagePreferences.isBuildEnabled(vmd)) |
| vmd.setBuildValidation(true); |
| else |
| vmd.setBuildValidation(false); |
| |
| } |
| validatorList.refresh(); |
| } |
| |
| protected void updateTableForDefaults() throws InvocationTargetException { |
| TableItem[] items = validatorsTable.getItems(); |
| for (int i = 0; i < items.length; i++) { |
| TableItem item = items[i]; |
| ValidatorMetaData vmd = (ValidatorMetaData) item.getData(); |
| |
| // Should the validator be enabled? Read the user's preferences from last time, |
| // if they exist, and set from that. If they don't exist, use the Validator class' |
| // default value. |
| if(pagePreferences.isEnabled(vmd)) { |
| vmd.setManualValidation(true); |
| vmd.setBuildValidation(true); |
| } else { |
| vmd.setManualValidation(false); |
| vmd.setBuildValidation(false); |
| } |
| } |
| validatorList.refresh(); |
| } |
| |
| protected void enableManualAndBuildValues() { |
| TableItem[] items = validatorsTable.getItems(); |
| for (int i = 0; i < items.length; i++) { |
| TableItem item = items[i]; |
| ValidatorMetaData vmd = (ValidatorMetaData) item.getData(); |
| vmd.setManualValidation(true); |
| vmd.setBuildValidation(true); |
| } |
| validatorList.refresh(); |
| } |
| |
| protected void disableManualAndBuildValues() { |
| TableItem[] items = validatorsTable.getItems(); |
| for (int i = 0; i < items.length; i++) { |
| TableItem item = items[i]; |
| ValidatorMetaData vmd = (ValidatorMetaData) item.getData(); |
| vmd.setManualValidation(false); |
| vmd.setBuildValidation(false); |
| } |
| validatorList.refresh(); |
| } |
| |
| public boolean performOk() throws InvocationTargetException { |
| storeValues(); |
| updateTaskList(); |
| return true; |
| } |
| |
| public boolean performDefaults() throws InvocationTargetException { |
| pagePreferences.resetToDefault(); |
| updateWidgetsForDefaults(); |
| getDefaultsButton().setFocus(); |
| return true; |
| } |
| |
| public boolean performEnableAll() throws InvocationTargetException { |
| setAllValidators(true); |
| pagePreferences.setEnabledValidators(getEnabledValidators()); |
| enableManualAndBuildValues(); |
| enableAllButton.setFocus(); |
| return true; |
| } |
| |
| /** |
| * |
| */ |
| private void setAllValidators(boolean bool) { |
| TableItem[] items = validatorsTable.getItems(); |
| for (int i = 0; i < items.length; i++) { |
| ValidatorMetaData validatorMetaData = (ValidatorMetaData) items[i].getData(); |
| validatorMetaData.setManualValidation(bool); |
| validatorMetaData.setBuildValidation(bool); |
| } |
| } |
| |
| public ValidatorMetaData[] getEnabledValidators() { |
| List enabledValidators = new ArrayList(); |
| TableItem[] items = validatorsTable.getItems(); |
| for (int i = 0; i < items.length; i++) { |
| ValidatorMetaData validatorMetaData = (ValidatorMetaData) items[i].getData(); |
| if(validatorMetaData.isManualValidation() || validatorMetaData.isBuildValidation()) |
| enabledValidators.add(validatorMetaData); |
| } |
| return (ValidatorMetaData[])enabledValidators.toArray(new ValidatorMetaData[enabledValidators.size()]); |
| } |
| |
| public ValidatorMetaData[] getEnabledManualValidators() { |
| List enabledValidators = new ArrayList(); |
| TableItem[] items = validatorsTable.getItems(); |
| for (int i = 0; i < items.length; i++) { |
| ValidatorMetaData validatorMetaData = (ValidatorMetaData) items[i].getData(); |
| if(validatorMetaData.isManualValidation()) |
| enabledValidators.add(validatorMetaData); |
| } |
| return (ValidatorMetaData[])enabledValidators.toArray(new ValidatorMetaData[enabledValidators.size()]); |
| |
| } |
| |
| public ValidatorMetaData[] getEnabledBuildValidators() { |
| List enabledValidators = new ArrayList(); |
| TableItem[] items = validatorsTable.getItems(); |
| for (int i = 0; i < items.length; i++) { |
| ValidatorMetaData validatorMetaData = (ValidatorMetaData) items[i].getData(); |
| if(validatorMetaData.isBuildValidation()) |
| enabledValidators.add(validatorMetaData); |
| } |
| return (ValidatorMetaData[])enabledValidators.toArray(new ValidatorMetaData[enabledValidators.size()]); |
| |
| } |
| |
| public boolean performDisableAll() throws InvocationTargetException { |
| setAllValidators(false); |
| pagePreferences.setEnabledValidators(getEnabledValidators()); |
| disableManualAndBuildValues(); |
| disableAllButton.setFocus(); |
| return true; |
| } |
| |
| protected void updateHelp() { |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(disableAllValidation, ContextIds.VALIDATION_PREFERENCE_PAGE_DISABLE_ALL_ENABLED); |
| } |
| |
| /* |
| * Store the current values of the controls into the preference store. |
| */ |
| private void storeValues() throws InvocationTargetException { |
| pagePreferences.setCanProjectsOverride(overrideButton.getSelection()); |
| |
| if (disableAllValidation.isEnabled()) { |
| pagePreferences.setDisableAllValidation(disableAllValidation.getSelection()); |
| } |
| //pagePreferences.setEnabledValidators(getEnabledValidators()); |
| |
| pagePreferences.setEnabledManualValidators(getEnabledManualValidators()); |
| |
| pagePreferences.setEnabledBuildValidators(getEnabledBuildValidators()); |
| |
| pagePreferences.passivate(); |
| pagePreferences.store(); |
| |
| // If the projects aren't allowed to override, clear their settings. |
| if (!pagePreferences.canProjectsOverride()) { |
| IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| IProject[] projects = workspace.getRoot().getProjects(); |
| for (int i = 0; i < projects.length; i++) { |
| IProject project = projects[i]; |
| try { |
| if (project.isOpen()) { |
| if (ConfigurationManager.getManager().isMigrated(project)) { |
| ProjectConfiguration prjp = ConfigurationManager.getManager().getProjectConfiguration(project); |
| prjp.setDoesProjectOverride(false); |
| prjp.passivate(); |
| prjp.store(); |
| } |
| } |
| } catch (InvocationTargetException exc) { |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } |
| } |
| } |
| |
| } |
| |
| private void updateTaskList() { |
| IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| IProject[] projects = workspace.getRoot().getProjects(); |
| boolean allowChanged = (pagePreferences.canProjectsOverride() != _allow); |
| for (int i = 0; i < projects.length; i++) { |
| IProject project = projects[i]; |
| try { |
| if (project.isOpen()) { |
| ProjectConfiguration prjp = ConfigurationManager.getManager().getProjectConfiguration(project); |
| if (!prjp.doesProjectOverride() && (prjp.hasEnabledValidatorsChanged(_oldVmd, allowChanged) || true) && |
| (prjp.haveDelegatesChanged(_oldDelegates, allowChanged) || true)) { |
| // If the project used to override the preferences, and the preferences |
| // make that impossible now, then update the task list. |
| // |
| // If the preferences allow projects to override, and they don't, and if |
| // the validators have changed, then update the task list. |
| ValidatorManager.getManager().updateTaskList(project); // Do not remove |
| // the exceeded message; only ValidationOperation should do that |
| // because it's about to run validation. If the limit is increased, |
| //messages may still be missing, so don't remove the "messages |
| // may be missing" message. |
| } |
| } |
| } catch (InvocationTargetException exc) { |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } |
| } |
| } |
| |
| public Composite getControl() { |
| return page; |
| } |
| |
| public void dispose() { |
| listLabel.dispose(); |
| overrideButton.dispose(); |
| disableAllValidation.dispose(); |
| emptyRowPlaceholder.dispose(); |
| disableAllButton.dispose(); |
| enableAllButton.dispose(); |
| validatorList.getTable().dispose(); |
| composite.dispose(); |
| } |
| |
| public void loseFocus() { |
| // This page does not need to cache anything before it loses focus. |
| } |
| |
| public void gainFocus() {/* |
| // This page depends on the Workbench Preference page, so update the value of the |
| // isAutoBuild (in case the workbench page's value has changed), and then update |
| // this page's widgets. |
| try { |
| //_isAutoBuildEnabled = ValidatorManager.getManager().isGlobalAutoBuildEnabled(); |
| updateWidgets(); |
| } catch (InvocationTargetException exc) { |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } |
| */} |
| } |
| |
| /* |
| * @see PreferencePage#createContents(Composite) |
| */ |
| protected Control createContents(Composite parent) { |
| try { |
| GlobalConfiguration gp = ConfigurationManager.getManager().getGlobalConfiguration(); |
| if (gp.numberOfValidators() == 0) { |
| _pageImpl = new NoValidatorsPage(parent); |
| } else { |
| try { |
| _pageImpl = new ValidatorListPage(parent); |
| } catch (InvocationTargetException exc) { |
| _pageImpl = new InvalidPage(parent); |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } catch (Exception exc) { |
| _pageImpl = new InvalidPage(parent); |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } |
| } |
| } catch (InvocationTargetException exc) { |
| _pageImpl = new InvalidPage(parent); |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } catch (Exception exc) { |
| _pageImpl = new InvalidPage(parent); |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } |
| |
| return _pageImpl.getControl(); |
| } |
| |
| /* |
| * @see IWorkbenchPreferencePage#init(IWorkbench) |
| */ |
| public void init(IWorkbench workbench) { |
| //init |
| } |
| |
| protected void noDefaultAndApplyButton() { |
| super.noDefaultAndApplyButton(); |
| } |
| |
| /** |
| * Performs special processing when this page's Defaults button has been pressed. |
| * <p> |
| * This is a framework hook method for sublcasses to do special things when the Defaults button |
| * has been pressed. Subclasses may override, but should call <code>super.performDefaults</code>. |
| * </p> |
| */ |
| protected void performDefaults() { |
| super.performDefaults(); |
| |
| try { |
| _pageImpl.performDefaults(); |
| } catch (InvocationTargetException exc) { |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } catch (Exception exc) { |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } |
| } |
| |
| /** |
| * When the user presses the "OK" or "Apply" button on the Properties Guide/Properties Page, |
| * respectively, some processing is performed by this PropertyPage. If the page is found, and |
| * completes successfully, true is returned. Otherwise, false is returned, and the guide doesn't |
| * finish. |
| */ |
| public boolean performOk() { |
| try { |
| return _pageImpl.performOk(); |
| } catch (InvocationTargetException exc) { |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| return false; |
| } catch (Exception exc) { |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| return false; |
| } |
| } |
| |
| /** |
| * Since the pages are inner classes of a child PreferencePage, not a PreferencePage itself, |
| * DialogPage's automatic disposal of its children's widgets cannot be used. Instead, dispose of |
| * each inner class' widgets explicitly. |
| */ |
| public void dispose() { |
| super.dispose(); |
| try { |
| if (_pageImpl != null) { |
| _pageImpl.dispose(); |
| } |
| } catch (Exception exc) { |
| displayAndLogError(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_TITLE), ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_INTERNAL_PAGE), exc); |
| } |
| } |
| |
| private void logError(Throwable exc) { |
| Logger logger = WTPUIPlugin.getLogger(); |
| if (logger.isLoggingLevel(Level.SEVERE)) { |
| LogEntry entry = ValidationUIPlugin.getLogEntry(); |
| entry.setSourceIdentifier("ValidationPreferencePage.displayAndLogError"); //$NON-NLS-1$ |
| entry.setMessageTypeIdentifier(ResourceConstants.VBF_EXC_INTERNAL_PAGE); |
| entry.setTargetException(exc); |
| logger.write(Level.SEVERE, entry); |
| |
| if (exc instanceof InvocationTargetException) { |
| if (((InvocationTargetException) exc).getTargetException() != null) { |
| entry.setTargetException(((InvocationTargetException) exc).getTargetException()); |
| logger.write(Level.SEVERE, entry); |
| } |
| } |
| } |
| } |
| |
| /** |
| * package visibility because if this method is private, then the compiler needs to create a |
| * synthetic accessor method for the internal classes, and that can have performance |
| * implications. |
| */ |
| void displayAndLogError(String title, String message, Throwable exc) { |
| logError(exc); |
| displayMessage(title, message, org.eclipse.swt.SWT.ICON_ERROR); |
| } |
| |
| private void displayMessage(String title, String message, int iIconType) { |
| MessageBox messageBox = new MessageBox(getShell(), org.eclipse.swt.SWT.OK | iIconType | org.eclipse.swt.SWT.APPLICATION_MODAL); |
| messageBox.setMessage(message); |
| messageBox.setText(title); |
| messageBox.open(); |
| } |
| |
| /** |
| * @see org.eclipse.jface.dialogs.IDialogPage#setVisible(boolean) |
| */ |
| public void setVisible(boolean visible) { |
| super.setVisible(visible); |
| if (_pageImpl == null) |
| return; |
| if (visible) { |
| _pageImpl.gainFocus(); |
| } else { |
| _pageImpl.loseFocus(); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.jface.preference.PreferencePage#getDefaultsButton() |
| */ |
| protected Button getDefaultsButton() { |
| return super.getDefaultsButton(); |
| } |
| } |