| /* | |
| * Copyright (C) 2012 The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| package com.motorolamobility.preflighting.ui.tabs; | |
| import java.util.ArrayList; | |
| import java.util.HashMap; | |
| import java.util.HashSet; | |
| import java.util.Iterator; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Set; | |
| import java.util.StringTokenizer; | |
| import org.eclipse.core.runtime.IStatus; | |
| import org.eclipse.core.runtime.Status; | |
| import org.eclipse.jface.preference.IPreferenceStore; | |
| import org.eclipse.jface.viewers.CellEditor; | |
| import org.eclipse.jface.viewers.CellLabelProvider; | |
| import org.eclipse.jface.viewers.CheckStateChangedEvent; | |
| import org.eclipse.jface.viewers.CheckboxTableViewer; | |
| import org.eclipse.jface.viewers.ColumnViewer; | |
| import org.eclipse.jface.viewers.ColumnViewerToolTipSupport; | |
| import org.eclipse.jface.viewers.ComboBoxCellEditor; | |
| import org.eclipse.jface.viewers.EditingSupport; | |
| import org.eclipse.jface.viewers.ICheckStateListener; | |
| import org.eclipse.jface.viewers.IStructuredContentProvider; | |
| import org.eclipse.jface.viewers.StructuredSelection; | |
| import org.eclipse.jface.viewers.TableViewer; | |
| import org.eclipse.jface.viewers.TableViewerColumn; | |
| import org.eclipse.jface.viewers.TextCellEditor; | |
| import org.eclipse.jface.viewers.Viewer; | |
| import org.eclipse.jface.viewers.ViewerCell; | |
| import org.eclipse.jface.viewers.ViewerComparator; | |
| 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.Control; | |
| import org.eclipse.swt.widgets.Group; | |
| import org.eclipse.swt.widgets.Layout; | |
| import org.eclipse.swt.widgets.Table; | |
| import org.eclipse.swt.widgets.TableColumn; | |
| import org.eclipse.swt.widgets.TableItem; | |
| import com.motorolamobility.preflighting.core.checker.CheckerDescription; | |
| import com.motorolamobility.preflighting.core.checker.condition.Condition; | |
| import com.motorolamobility.preflighting.core.validation.ValidationManager; | |
| import com.motorolamobility.preflighting.ui.PreflightingUIPlugin; | |
| import com.motorolamobility.preflighting.ui.i18n.PreflightingUiNLS; | |
| /** | |
| * This class represents the Checkers Tab on the App Validador preference page. | |
| */ | |
| public class CheckersTabComposite extends AbstractAppValidatorTabComposite | |
| { | |
| private final class CheckersColumnSelectionAdapter extends SelectionAdapter | |
| { | |
| private int columnIndex; | |
| public CheckersColumnSelectionAdapter(int columnIndex) | |
| { | |
| this.columnIndex = columnIndex; | |
| } | |
| @Override | |
| public void widgetSelected(SelectionEvent e) | |
| { | |
| checkersTableComparator.setColumn(columnIndex); | |
| checkersTableViewer.getTable().setSortColumn((TableColumn) e.getSource()); | |
| checkersTableViewer.getTable().setSortDirection( | |
| checkersTableComparator.getSwtDirection()); | |
| checkersTableViewer.refresh(); | |
| super.widgetSelected(e); | |
| } | |
| } | |
| private final class ConditionsColumnSelectionAdapter extends SelectionAdapter | |
| { | |
| private int columnIndex; | |
| public ConditionsColumnSelectionAdapter(int columnIndex) | |
| { | |
| this.columnIndex = columnIndex; | |
| } | |
| @Override | |
| public void widgetSelected(SelectionEvent e) | |
| { | |
| conditionsTableComparator.setColumn(columnIndex); | |
| conditionsTableViewer.getTable().setSortColumn((TableColumn) e.getSource()); | |
| conditionsTableViewer.getTable().setSortDirection( | |
| conditionsTableComparator.getSwtDirection()); | |
| conditionsTableViewer.refresh(); | |
| super.widgetSelected(e); | |
| } | |
| } | |
| private static final String NO_CHECKERS_SELECTED = "none"; //$NON-NLS-1$ | |
| /** | |
| * Checkers table label provider, provides Cell Text and Tooltip | |
| */ | |
| public class CheckersLabelProvider extends CellLabelProvider | |
| { | |
| /* | |
| * Display time in seconds | |
| */ | |
| private static final int TOOLTIP_DISPLAYTIME = 10; | |
| /* | |
| * (non-Javadoc) | |
| * @see org.eclipse.jface.viewers.CellLabelProvider#update(org.eclipse.jface.viewers.ViewerCell) | |
| */ | |
| @Override | |
| public void update(ViewerCell cell) | |
| { | |
| String text = ""; | |
| int columnIndex = cell.getColumnIndex(); | |
| CheckerDescription checkerDescription = (CheckerDescription) cell.getElement(); | |
| switch (columnIndex) | |
| { | |
| case NAME_COLUMN_INDEX: | |
| text = checkerDescription.getName(); | |
| break; | |
| case ID_COLUMN_INDEX: | |
| text = checkerDescription.getId(); | |
| break; | |
| case CHECKER_PARAMS_COLUMN_INDEX: | |
| String checkerId = checkerDescription.getId(); | |
| text = checkerParams.containsKey(checkerId) ? checkerParams.get(checkerId) : ""; | |
| break; | |
| case CHECKER_CHANGE_WARNING_LEVEL_COLUMN_INDEX: | |
| text = | |
| getWarningLevelText(customCheckersWarningLevels.get(checkerDescription | |
| .getId())); | |
| break; | |
| default: | |
| break; | |
| } | |
| cell.setText(text); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * @see org.eclipse.jface.viewers.CellLabelProvider#getToolTipDisplayDelayTime(java.lang.Object) | |
| */ | |
| @Override | |
| public int getToolTipDisplayDelayTime(Object object) | |
| { | |
| return 200; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * @see org.eclipse.jface.viewers.CellLabelProvider#getToolTipTimeDisplayed(java.lang.Object) | |
| */ | |
| @Override | |
| public int getToolTipTimeDisplayed(Object object) | |
| { | |
| return TOOLTIP_DISPLAYTIME * 1000; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * @see org.eclipse.jface.viewers.CellLabelProvider#getToolTipText(java.lang.Object) | |
| */ | |
| @Override | |
| public String getToolTipText(Object element) | |
| { | |
| CheckerDescription checkerDescription = (CheckerDescription) element; | |
| return checkerDescription.getDescription(); | |
| } | |
| } | |
| /** | |
| * Conditions table label provider, provides Cell Text and Tooltip | |
| */ | |
| public class ConditionsLabelProvider extends CellLabelProvider | |
| { | |
| /* | |
| * Display time in seconds | |
| */ | |
| private static final int TOOLTIP_DISPLAYTIME = 10; | |
| @Override | |
| public void update(ViewerCell cell) | |
| { | |
| String text = ""; | |
| int columnIndex = cell.getColumnIndex(); | |
| Condition condition = (Condition) cell.getElement(); | |
| switch (columnIndex) | |
| { | |
| case NAME_COLUMN_INDEX: | |
| text = condition.getName(); | |
| break; | |
| case ID_COLUMN_INDEX: | |
| text = condition.getId(); | |
| break; | |
| case CONDITION_WARNING_LEVEL_COLUMN_INDEX: | |
| text = condition.getSeverityLevel().toString(); | |
| break; | |
| case CONDITION_CHANGE_WARNING_LEVEL_COLUMN_INDEX: | |
| text = | |
| getWarningLevelText(customConditionsWarningLevels | |
| .get(condition.getId())); | |
| break; | |
| default: | |
| break; | |
| } | |
| cell.setText(text); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * @see org.eclipse.jface.viewers.CellLabelProvider#getToolTipDisplayDelayTime(java.lang.Object) | |
| */ | |
| @Override | |
| public int getToolTipDisplayDelayTime(Object object) | |
| { | |
| return 200; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * @see org.eclipse.jface.viewers.CellLabelProvider#getToolTipTimeDisplayed(java.lang.Object) | |
| */ | |
| @Override | |
| public int getToolTipTimeDisplayed(Object object) | |
| { | |
| return TOOLTIP_DISPLAYTIME * 1000; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * @see org.eclipse.jface.viewers.CellLabelProvider#getToolTipText(java.lang.Object) | |
| */ | |
| @Override | |
| public String getToolTipText(Object element) | |
| { | |
| Condition condition = (Condition) element; | |
| return condition.getDescription(); | |
| } | |
| } | |
| /** | |
| * Checkers Table content provider | |
| */ | |
| public class CheckersContentProvider implements IStructuredContentProvider | |
| { | |
| @SuppressWarnings("unchecked") | |
| public Object[] getElements(Object inputElement) | |
| { | |
| List<CheckerDescription> checkersDescription = (List<CheckerDescription>) inputElement; | |
| return checkersDescription.toArray(); | |
| } | |
| public void dispose() | |
| { | |
| //do nothing | |
| } | |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) | |
| { | |
| //do nothing | |
| } | |
| } | |
| /** | |
| * Conditions Table content provider | |
| */ | |
| public class ConditionsContentProvider implements IStructuredContentProvider | |
| { | |
| @SuppressWarnings("unchecked") | |
| public Object[] getElements(Object inputElement) | |
| { | |
| List<Condition> conditions = (List<Condition>) inputElement; | |
| return conditions.toArray(); | |
| } | |
| public void dispose() | |
| { | |
| //do nothing | |
| } | |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) | |
| { | |
| //do nothing | |
| } | |
| } | |
| /** | |
| * Table comparator | |
| * Add sort functionality for checkers | |
| */ | |
| private class CheckersTableComparator extends ViewerComparator | |
| { | |
| private final int ORDER_ASC = 1; | |
| private final int ORDER_DESC = -1; | |
| /** | |
| * Column that must be used to sort elements | |
| */ | |
| private int column = -1; | |
| private int direction = ORDER_ASC; | |
| public void setColumn(int column) | |
| { | |
| if (this.column == column) | |
| { | |
| direction = direction == ORDER_ASC ? ORDER_DESC : ORDER_ASC; | |
| } | |
| else | |
| { | |
| this.column = column; | |
| direction = ORDER_ASC; | |
| } | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * @see org.eclipse.jface.viewers.ViewerComparator#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object) | |
| */ | |
| @Override | |
| public int compare(Viewer viewer, Object e1, Object e2) | |
| { | |
| CheckerDescription checkerLeft = (CheckerDescription) e1; | |
| CheckerDescription checkerRight = (CheckerDescription) e2; | |
| String left = ""; //$NON-NLS-1$ | |
| String right = ""; //$NON-NLS-1$ | |
| switch (column) | |
| { | |
| case NAME_COLUMN_INDEX: | |
| left = checkerLeft.getName(); | |
| right = checkerRight.getName(); | |
| break; | |
| case ID_COLUMN_INDEX: | |
| left = checkerLeft.getId(); | |
| right = checkerRight.getId(); | |
| break; | |
| case CHECKER_PARAMS_COLUMN_INDEX: | |
| String leftParams = checkerParams.get(checkerLeft.getId()); | |
| String rightParams = checkerParams.get(checkerRight.getId()); | |
| left = ((leftParams != null) ? leftParams : ""); | |
| right = ((rightParams != null) ? rightParams : ""); | |
| break; | |
| case CHECKER_CHANGE_WARNING_LEVEL_COLUMN_INDEX: | |
| Boolean leftWarningLevel = customCheckersWarningLevels.get(checkerLeft.getId()); | |
| Boolean rightWarningLevel = | |
| customCheckersWarningLevels.get(checkerRight.getId()); | |
| left = ((leftWarningLevel != null) ? leftWarningLevel.toString() : ""); | |
| right = ((rightWarningLevel != null) ? rightWarningLevel.toString() : ""); | |
| break; | |
| default: | |
| break; | |
| } | |
| return left.compareTo(right) * direction; | |
| } | |
| /** | |
| * Returns the SWT constant which represents the direction | |
| * @return | |
| */ | |
| public int getSwtDirection() | |
| { | |
| return direction == ORDER_ASC ? SWT.UP : SWT.DOWN; | |
| } | |
| } | |
| /** | |
| * Conditions comparator | |
| * Add sort functionality for checkers | |
| */ | |
| private class ConditionsTableComparator extends ViewerComparator | |
| { | |
| private final int ORDER_ASC = 1; | |
| private final int ORDER_DESC = -1; | |
| /** | |
| * Column that must be used to sort elements | |
| */ | |
| private int column = -1; | |
| private int direction = ORDER_ASC; | |
| public void setColumn(int column) | |
| { | |
| if (this.column == column) | |
| { | |
| direction = direction == ORDER_ASC ? ORDER_DESC : ORDER_ASC; | |
| } | |
| else | |
| { | |
| this.column = column; | |
| direction = ORDER_ASC; | |
| } | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * @see org.eclipse.jface.viewers.ViewerComparator#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object) | |
| */ | |
| @Override | |
| public int compare(Viewer viewer, Object e1, Object e2) | |
| { | |
| Condition conditionLeft = (Condition) e1; | |
| Condition conditionRight = (Condition) e2; | |
| String left = ""; //$NON-NLS-1$ | |
| String right = ""; //$NON-NLS-1$ | |
| switch (column) | |
| { | |
| case NAME_COLUMN_INDEX: | |
| left = conditionLeft.getName(); | |
| right = conditionRight.getName(); | |
| break; | |
| case ID_COLUMN_INDEX: | |
| left = conditionLeft.getId(); | |
| right = conditionRight.getId(); | |
| break; | |
| case CHECKER_PARAMS_COLUMN_INDEX: | |
| left = conditionLeft.getSeverityLevel().toString(); | |
| right = conditionRight.getSeverityLevel().toString(); | |
| break; | |
| case CHECKER_CHANGE_WARNING_LEVEL_COLUMN_INDEX: | |
| Boolean leftWarningLevel = | |
| customConditionsWarningLevels.get(conditionLeft.getId()); | |
| Boolean rightWarningLevel = | |
| customConditionsWarningLevels.get(conditionRight.getId()); | |
| left = ((leftWarningLevel != null) ? leftWarningLevel.toString() : ""); | |
| right = ((rightWarningLevel != null) ? rightWarningLevel.toString() : ""); | |
| break; | |
| default: | |
| break; | |
| } | |
| return left.compareTo(right) * direction; | |
| } | |
| /** | |
| * Returns the SWT constant which represents the direction | |
| * @return | |
| */ | |
| public int getSwtDirection() | |
| { | |
| return direction == ORDER_ASC ? SWT.UP : SWT.DOWN; | |
| } | |
| } | |
| /* | |
| * Table columns | |
| */ | |
| private static final int NAME_COLUMN_INDEX = 0; | |
| private static final int ID_COLUMN_INDEX = 1; | |
| private static final int CONDITION_WARNING_LEVEL_COLUMN_INDEX = 2; | |
| private static final int CONDITION_CHANGE_WARNING_LEVEL_COLUMN_INDEX = 3; | |
| private static final int CHECKER_PARAMS_COLUMN_INDEX = 2; | |
| private static final int CHECKER_CHANGE_WARNING_LEVEL_COLUMN_INDEX = 3; | |
| /** | |
| * The Checkers TableViewer | |
| */ | |
| private CheckboxTableViewer checkersTableViewer; | |
| /** | |
| * The Conditions TableViewer | |
| */ | |
| private CheckboxTableViewer conditionsTableViewer; | |
| /** | |
| * The Select All checkbox for checkers | |
| */ | |
| private Button selectAllCheckersCheck; | |
| /** | |
| * The Select All checkbox for conditions | |
| */ | |
| private Button selectAllConditionsCheck; | |
| /** | |
| * A list with all CheckerDescription | |
| */ | |
| private List<CheckerDescription> checkersDescriptions; | |
| /** | |
| * The model which keeps checker params, Key is checkerId and value is the Parameters String | |
| */ | |
| private Map<String, String> checkerParams; | |
| /** | |
| * The model which keeps the custom warning levels, Key is checkerId and value is a Boolean that indicates: | |
| * true -> increases warning level | |
| * false -> decreases warning level | |
| * null and/or inexistent -> no change | |
| */ | |
| private Map<String, Boolean> customCheckersWarningLevels = new HashMap<String, Boolean>(); | |
| private Map<String, Boolean> customConditionsWarningLevels = new HashMap<String, Boolean>(); | |
| /** | |
| * The model which keeps all conditions, Key is checkerId and value is a list of its conditions | |
| */ | |
| private Map<String, List<Condition>> allConditionsMap = new HashMap<String, List<Condition>>(); | |
| /** | |
| * The model which keeps only the selected conditions, Key is checkerId and value is a list of its selected conditions | |
| */ | |
| private Map<String, List<Condition>> selectedConditionsMap = | |
| new HashMap<String, List<Condition>>(); | |
| /** | |
| * Warning Level Operations (increase, keep, decrease) | |
| * Currently, it's not possible to set the warning level, you can only increase or decrease it | |
| */ | |
| private String[] WarningLevelOperations = | |
| { | |
| PreflightingUiNLS.CheckersTabComposite_WarningLevel_Operation_Increase, | |
| PreflightingUiNLS.CheckersTabComposite_WarningLevel_Operation_Kepp, | |
| PreflightingUiNLS.CheckersTabComposite_WarningLevel_Operation_Decrease | |
| }; | |
| /** | |
| * Checkers table comparator, used for sort functionality | |
| */ | |
| private CheckersTableComparator checkersTableComparator; | |
| /** | |
| * Conditions table comparator, used for sort functionality | |
| */ | |
| private ConditionsTableComparator conditionsTableComparator; | |
| /** | |
| * Return the text that represents the warning level change, which is | |
| * saved as a boolean | |
| * | |
| * true -> increases warning level | |
| * false -> decreases warning level | |
| * null -> no change | |
| * | |
| * @param action the value stored | |
| * @return the corresponding warning level operation | |
| */ | |
| public String getWarningLevelText(Boolean action) | |
| { | |
| String result = PreflightingUiNLS.CheckersTabComposite_WarningLevel_Operation_Kepp; | |
| if (action != null) | |
| { | |
| if (action) | |
| { | |
| result = PreflightingUiNLS.CheckersTabComposite_WarningLevel_Operation_Increase; | |
| } | |
| else | |
| { | |
| result = PreflightingUiNLS.CheckersTabComposite_WarningLevel_Operation_Decrease; | |
| } | |
| } | |
| return result; | |
| } | |
| /** | |
| * Initialize all UI items | |
| * | |
| * @param parent the parent composite | |
| * @param style the SWT styles | |
| * @param preferenceStore the preference store | |
| */ | |
| public CheckersTabComposite(Composite parent, int style, IPreferenceStore preferenceStore) | |
| { | |
| super(parent, style); | |
| Layout layout = new GridLayout(1, false); | |
| this.setLayout(layout); | |
| createCheckersComposite(); | |
| init(preferenceStore); | |
| } | |
| /** | |
| * Creates the composite which will have the checkers and also | |
| * the conditions selection | |
| */ | |
| private void createCheckersComposite() | |
| { | |
| Layout layout; | |
| Composite composite = new Composite(this, SWT.NONE); | |
| layout = new GridLayout(1, true); | |
| composite.setLayout(layout); | |
| GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true); | |
| composite.setLayoutData(gd); | |
| /* | |
| * Create checkers group | |
| */ | |
| createCheckersGroup(composite); | |
| /* | |
| * Include the conditions area in the checker group. | |
| * This are is updated according to the checker selection | |
| */ | |
| createConditionsGroup(composite); | |
| } | |
| /** | |
| * Create and return the Checkers group. | |
| * It contains the table with all checkers listed. When a checker is | |
| * selected, the corresponding conditions are updated in the conditions | |
| * table. | |
| * | |
| * @param topComposite the parent composite | |
| */ | |
| private void createCheckersGroup(Composite topComposite) | |
| { | |
| Group checkersGroup = new Group(topComposite, SWT.NONE); | |
| checkersGroup.setLayout(new GridLayout(1, false)); | |
| checkersGroup.setText(PreflightingUiNLS.CheckersTabComposite_Checkers_Group); | |
| GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true); | |
| checkersGroup.setLayoutData(gd); | |
| checkersTableViewer = | |
| CheckboxTableViewer.newCheckList(checkersGroup, SWT.BORDER | SWT.SINGLE | |
| | SWT.FULL_SELECTION); | |
| Control checkersTableControl = checkersTableViewer.getTable(); | |
| gd = new GridData(SWT.FILL, SWT.FILL, true, true); | |
| checkersTableControl.setLayoutData(gd); | |
| checkersTableComparator = new CheckersTableComparator(); | |
| checkersTableViewer.setComparator(checkersTableComparator); | |
| /* | |
| * Create Columns | |
| */ | |
| TableViewerColumn column = new TableViewerColumn(checkersTableViewer, SWT.NONE); // Name | |
| column.getColumn().setText(PreflightingUiNLS.CheckersTabComposite_Name_Column); | |
| column.getColumn().setResizable(true); | |
| column.getColumn().setWidth(230); | |
| column.setLabelProvider(new CheckersLabelProvider()); | |
| column.getColumn().addSelectionListener( | |
| new CheckersColumnSelectionAdapter(NAME_COLUMN_INDEX)); | |
| column = new TableViewerColumn(checkersTableViewer, SWT.NONE); // ID | |
| column.getColumn().setText(PreflightingUiNLS.CheckersTabComposite_Id_Column); | |
| column.getColumn().setResizable(true); | |
| column.getColumn().setWidth(100); | |
| column.setLabelProvider(new CheckersLabelProvider()); | |
| column.getColumn() | |
| .addSelectionListener(new CheckersColumnSelectionAdapter(ID_COLUMN_INDEX)); | |
| column = new TableViewerColumn(checkersTableViewer, SWT.NONE); // Parameters | |
| column.getColumn().setText(PreflightingUiNLS.CheckersTabComposite_Checker_Params_Column); | |
| column.getColumn().setResizable(true); | |
| column.getColumn().setWidth(100); | |
| column.setLabelProvider(new CheckersLabelProvider()); | |
| column.getColumn().addSelectionListener( | |
| new CheckersColumnSelectionAdapter(CHECKER_PARAMS_COLUMN_INDEX)); | |
| // set a custom editor for this column | |
| column.setEditingSupport(new ParameterEditingSupport(checkersTableViewer)); | |
| column = new TableViewerColumn(checkersTableViewer, SWT.NONE); // Change Warning Level | |
| column.getColumn() | |
| .setText(PreflightingUiNLS.CheckersTabComposite_ChangeWarningLevel_Column); | |
| column.getColumn().setResizable(true); | |
| column.getColumn().setWidth(100); | |
| column.setLabelProvider(new CheckersLabelProvider()); | |
| column.getColumn().addSelectionListener( | |
| new CheckersColumnSelectionAdapter(CHECKER_CHANGE_WARNING_LEVEL_COLUMN_INDEX)); | |
| // set a custom editor for this column | |
| column.setEditingSupport(new WarningLevelEditingSupport(checkersTableViewer)); | |
| checkersTableViewer.getTable().setHeaderVisible(true); | |
| checkersTableViewer.setContentProvider(new CheckersContentProvider()); | |
| ColumnViewerToolTipSupport.enableFor(checkersTableViewer); | |
| // Selection Change Listener handles needed UI updates on the paramsText according to checkers selected | |
| // It also updates the conditions table | |
| checkersTableViewer.getTable().addSelectionListener(new SelectionAdapter() | |
| { | |
| @Override | |
| public void widgetSelected(SelectionEvent e) | |
| { | |
| CheckerDescription checkerDescription = (CheckerDescription) e.item.getData(); | |
| TableItem tableItem = (TableItem) e.item; | |
| updateConditionTableBasedOnChecker(tableItem.getChecked()); | |
| populateConditionsTable(checkerDescription.getId()); | |
| } | |
| }); | |
| // CheckStateListener handles the selectAll check box behavior and also selects the clicked item on the table. | |
| checkersTableViewer.addCheckStateListener(new ICheckStateListener() | |
| { | |
| public void checkStateChanged(CheckStateChangedEvent event) | |
| { | |
| boolean isAllSelected = areAllItemsChecked(checkersTableViewer); | |
| selectAllCheckersCheck.setSelection(isAllSelected); | |
| checkersTableViewer.setSelection(new StructuredSelection(event.getElement()), true); | |
| updateConditionTableBasedOnChecker(event.getChecked()); | |
| notifyListener(); | |
| } | |
| }); | |
| ValidationManager validationManager = new ValidationManager(); | |
| checkersDescriptions = validationManager.getCheckersDescription(); | |
| checkerParams = new HashMap<String, String>(checkersDescriptions.size()); | |
| checkersTableViewer.setInput(checkersDescriptions); | |
| selectAllCheckersCheck = new Button(checkersGroup, SWT.CHECK); | |
| selectAllCheckersCheck | |
| .setText(PreflightingUiNLS.CheckersTabComposite_Checkers_SelectAll_Check); | |
| gd = new GridData(SWT.LEFT, SWT.BOTTOM, false, false); | |
| selectAllCheckersCheck.setLayoutData(gd); | |
| selectAllCheckersCheck.setSelection(true); | |
| selectAllCheckersCheck.addSelectionListener(new SelectionAdapter() | |
| { | |
| @Override | |
| public void widgetSelected(SelectionEvent e) | |
| { | |
| checkersTableViewer.setAllChecked(selectAllCheckersCheck.getSelection()); | |
| updateConditionTableBasedOnChecker(selectAllCheckersCheck.getSelection()); | |
| super.widgetSelected(e); | |
| notifyListener(); | |
| } | |
| }); | |
| checkersTableComparator.setColumn(0); | |
| } | |
| /** | |
| * @param event | |
| */ | |
| public void updateConditionTableBasedOnChecker(boolean checkerEnabled) | |
| { | |
| if (!checkerEnabled) | |
| { | |
| //disabling checker => disable all conditions as well (and disable the table) | |
| conditionsTableViewer.getTable().setEnabled(false); | |
| selectAllConditionsCheck.setEnabled(false); | |
| } | |
| else | |
| { | |
| //enabling checker => enables all conditions as well (and enable the table) | |
| conditionsTableViewer.getTable().setEnabled(true); | |
| selectAllConditionsCheck.setEnabled(true); | |
| } | |
| } | |
| /** | |
| * Create the conditions are, which contains a table with all | |
| * conditions of the selected checker. Its content is updated | |
| * dynamically based on the checker selection | |
| * | |
| * @param topComposite the parent composite | |
| */ | |
| /** | |
| * @param topComposite | |
| */ | |
| private void createConditionsGroup(Composite topComposite) | |
| { | |
| Group conditionsGroup = new Group(topComposite, SWT.NONE); | |
| conditionsGroup.setLayout(new GridLayout(1, false)); | |
| conditionsGroup.setText(PreflightingUiNLS.CheckersTabComposite_Conditions_Group); | |
| GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true); | |
| gd.heightHint = 200; | |
| conditionsGroup.setLayoutData(gd); | |
| conditionsTableViewer = | |
| CheckboxTableViewer.newCheckList(conditionsGroup, SWT.BORDER | SWT.MULTI | |
| | SWT.FULL_SELECTION); | |
| Control conditionsTableControl = conditionsTableViewer.getTable(); | |
| gd.heightHint = 200; | |
| conditionsTableControl.setLayoutData(gd); | |
| conditionsTableViewer.setContentProvider(new ConditionsContentProvider()); | |
| ColumnViewerToolTipSupport.enableFor(conditionsTableViewer); | |
| conditionsTableComparator = new ConditionsTableComparator(); | |
| conditionsTableViewer.setComparator(conditionsTableComparator); | |
| // Create Columns | |
| TableViewerColumn column = new TableViewerColumn(conditionsTableViewer, SWT.NONE); // Name | |
| column.getColumn().setText(PreflightingUiNLS.CheckersTabComposite_Name_Column); | |
| column.getColumn().setResizable(true); | |
| column.getColumn().setWidth(230); | |
| column.setLabelProvider(new ConditionsLabelProvider()); | |
| column.getColumn().addSelectionListener( | |
| new ConditionsColumnSelectionAdapter(NAME_COLUMN_INDEX)); | |
| column = new TableViewerColumn(conditionsTableViewer, SWT.NONE); // ID | |
| column.getColumn().setText(PreflightingUiNLS.CheckersTabComposite_Id_Column); | |
| column.getColumn().setResizable(true); | |
| column.getColumn().setWidth(100); | |
| column.setLabelProvider(new ConditionsLabelProvider()); | |
| column.getColumn().addSelectionListener( | |
| new ConditionsColumnSelectionAdapter(ID_COLUMN_INDEX)); | |
| column = new TableViewerColumn(conditionsTableViewer, SWT.NONE); // Warning Level | |
| column.getColumn().setText(PreflightingUiNLS.CheckersTabComposite_WarningLevel_Column); | |
| column.getColumn().setResizable(true); | |
| column.getColumn().setWidth(100); | |
| column.setLabelProvider(new ConditionsLabelProvider()); | |
| column.getColumn().addSelectionListener( | |
| new ConditionsColumnSelectionAdapter(CONDITION_WARNING_LEVEL_COLUMN_INDEX)); | |
| column = new TableViewerColumn(conditionsTableViewer, SWT.NONE); // Change Warning Level | |
| column.getColumn() | |
| .setText(PreflightingUiNLS.CheckersTabComposite_ChangeWarningLevel_Column); | |
| column.getColumn().setResizable(true); | |
| column.getColumn().setWidth(100); | |
| column.setLabelProvider(new ConditionsLabelProvider()); | |
| column.getColumn().addSelectionListener( | |
| new ConditionsColumnSelectionAdapter(CONDITION_CHANGE_WARNING_LEVEL_COLUMN_INDEX)); | |
| // set a custom editor for this column | |
| column.setEditingSupport(new WarningLevelEditingSupport(conditionsTableViewer)); | |
| conditionsTableViewer.getTable().setHeaderVisible(true); | |
| conditionsTableViewer.addCheckStateListener(new ICheckStateListener() | |
| { | |
| public void checkStateChanged(CheckStateChangedEvent event) | |
| { | |
| // update "select all" control | |
| boolean isAllSelected = areAllItemsChecked(conditionsTableViewer); | |
| selectAllConditionsCheck.setSelection(isAllSelected); | |
| // move the selection to the checked item | |
| conditionsTableViewer.setSelection(new StructuredSelection(event.getElement()), | |
| true); | |
| // get the condition and the checker that are selected | |
| Condition condition = (Condition) event.getElement(); | |
| CheckerDescription selectedChecker = | |
| (CheckerDescription) ((StructuredSelection) checkersTableViewer | |
| .getSelection()).getFirstElement(); | |
| // update the selected conditions maps accordingly, adding the specified condition | |
| // if the checkbox is checked or removing it otherwise | |
| List<Condition> conditions = selectedConditionsMap.get(selectedChecker.getId()); | |
| if (event.getChecked()) | |
| { | |
| conditions.add(condition); | |
| } | |
| else | |
| { | |
| conditions.remove(condition); | |
| } | |
| notifyListener(); | |
| } | |
| }); | |
| selectAllConditionsCheck = new Button(conditionsGroup, SWT.CHECK); | |
| selectAllConditionsCheck | |
| .setText(PreflightingUiNLS.CheckersTabComposite_Checkers_SelectAll_Check); | |
| gd = new GridData(SWT.LEFT, SWT.BOTTOM, false, false); | |
| selectAllConditionsCheck.setLayoutData(gd); | |
| selectAllConditionsCheck.setSelection(true); | |
| selectAllConditionsCheck.addSelectionListener(new SelectionAdapter() | |
| { | |
| @Override | |
| public void widgetSelected(SelectionEvent e) | |
| { | |
| // update UI | |
| conditionsTableViewer.setAllChecked(selectAllConditionsCheck.getSelection()); | |
| // update model | |
| CheckerDescription selectedChecker = | |
| (CheckerDescription) ((StructuredSelection) checkersTableViewer | |
| .getSelection()).getFirstElement(); | |
| // get all conditions of the selected checker and add them to the selected conditions list | |
| if (selectAllConditionsCheck.getSelection()) | |
| { | |
| selectAllConditions(selectedChecker.getId()); | |
| } | |
| // clear the selected conditions list | |
| else | |
| { | |
| selectedConditionsMap.put(selectedChecker.getId(), new ArrayList<Condition>()); | |
| } | |
| super.widgetSelected(e); | |
| notifyListener(); | |
| } | |
| }); | |
| selectAllConditionsCheck.setEnabled(conditionsTableViewer.getTable().isEnabled()); | |
| conditionsTableComparator.setColumn(0); | |
| } | |
| /** | |
| * Select all conditions in the model, by copying the list with all conditions | |
| * | |
| * @param checkerId the checker id to have all its conditions selected | |
| */ | |
| private void selectAllConditions(String checkerId) | |
| { | |
| List<Condition> selectedConditions = new ArrayList<Condition>(); | |
| for (Condition condition : allConditionsMap.get(checkerId)) | |
| { | |
| selectedConditions.add(condition); | |
| } | |
| selectedConditionsMap.put(checkerId, selectedConditions); | |
| } | |
| /** | |
| * Create a custom cell editor which will contain a text editor so that | |
| * users can modify the parameters for a particular checker | |
| */ | |
| public class ParameterEditingSupport extends EditingSupport | |
| { | |
| public ParameterEditingSupport(ColumnViewer viewer) | |
| { | |
| super(viewer); | |
| } | |
| @Override | |
| protected void setValue(Object element, Object value) | |
| { | |
| checkerParams.put(((CheckerDescription) element).getId(), (String) value); | |
| getViewer().update(element, null); | |
| notifyListener(); | |
| } | |
| @Override | |
| protected Object getValue(Object element) | |
| { | |
| CheckerDescription checkerDescription = (CheckerDescription) element; | |
| String params = ""; //$NON-NLS-1$ | |
| if (checkerParams.containsKey(checkerDescription.getId())) | |
| { | |
| params = checkerParams.get(checkerDescription.getId()); | |
| } | |
| return params; | |
| } | |
| @Override | |
| protected CellEditor getCellEditor(Object element) | |
| { | |
| return new TextCellEditor(((TableViewer) getViewer()).getTable(), SWT.NONE); | |
| } | |
| @Override | |
| protected boolean canEdit(Object element) | |
| { | |
| return true; | |
| } | |
| } | |
| /** | |
| * Create a custom cell editor which will contain a combobox so that | |
| * users can modify (increase / decrease) the warning level for a particular | |
| * condition or checker | |
| */ | |
| public class WarningLevelEditingSupport extends EditingSupport | |
| { | |
| public WarningLevelEditingSupport(TableViewer viewer) | |
| { | |
| super(viewer); | |
| } | |
| @Override | |
| protected CellEditor getCellEditor(Object element) | |
| { | |
| CellEditor comboEditor = | |
| new ComboBoxCellEditor(((TableViewer) getViewer()).getTable(), | |
| WarningLevelOperations, SWT.READ_ONLY | SWT.FULL_SELECTION | |
| | SWT.DROP_DOWN); | |
| return comboEditor; | |
| } | |
| @Override | |
| protected boolean canEdit(Object element) | |
| { | |
| return true; | |
| } | |
| @Override | |
| protected Object getValue(Object element) | |
| { | |
| // Get value from model | |
| Boolean customWarningLevel = null; | |
| if (element instanceof Condition) | |
| { | |
| customWarningLevel = | |
| customConditionsWarningLevels.get(((Condition) element).getId()); | |
| } | |
| else | |
| { | |
| customWarningLevel = | |
| customCheckersWarningLevels.get(((CheckerDescription) element).getId()); | |
| } | |
| // select the appropriate item in the combobox | |
| int value = 1; // keep | |
| if (customWarningLevel != null) | |
| { | |
| value = ((customWarningLevel) ? 0 : 2); // increase, decrease | |
| } | |
| return new Integer(value); | |
| } | |
| @Override | |
| protected void setValue(Object element, Object value) | |
| { | |
| int intValue = ((Integer) value).intValue(); | |
| Boolean booleanValue = null; // 1 = default (keep warning level) | |
| if (intValue != 1) | |
| { | |
| booleanValue = ((intValue == 0) ? new Boolean(true) : new Boolean(false)); | |
| } | |
| // Set value in the model | |
| if (element instanceof Condition) | |
| { | |
| customConditionsWarningLevels.put(((Condition) element).getId(), booleanValue); | |
| } | |
| else | |
| { | |
| customCheckersWarningLevels.put(((CheckerDescription) element).getId(), | |
| booleanValue); | |
| } | |
| // Update the UI. This generate a call to the label provider | |
| getViewer().update(element, null); | |
| getViewer().refresh(); | |
| } | |
| } | |
| /** | |
| * Update the conditions table based on the checker that is selected | |
| * | |
| * @param checkerId the checker selected in the UI | |
| */ | |
| private void populateConditionsTable(String checkerId) | |
| { | |
| // display appropriate elements | |
| if (checkerId != null) | |
| { | |
| conditionsTableViewer.setInput(allConditionsMap.get(checkerId)); | |
| } | |
| else | |
| { | |
| conditionsTableViewer.setInput(new ArrayList<Condition>()); | |
| } | |
| // update selection in the table and also the "select all" button state | |
| conditionsTableViewer.setCheckedElements(selectedConditionsMap.get(checkerId).toArray()); | |
| selectAllConditionsCheck.setEnabled(conditionsTableViewer.getTable().isEnabled()); | |
| selectAllConditionsCheck.setSelection(areAllItemsChecked(conditionsTableViewer)); | |
| } | |
| /* | |
| * Verifies if all items on a given CheckboxTableViewer are selected | |
| */ | |
| private boolean areAllItemsChecked(CheckboxTableViewer tableViewer) | |
| { | |
| Table table = tableViewer.getTable(); | |
| TableItem[] items = table.getItems(); | |
| boolean allChecked = true; | |
| int i = 0; | |
| while ((i < items.length) && allChecked) | |
| { | |
| TableItem tableItem = items[i]; | |
| if (!tableItem.getChecked()) | |
| { | |
| allChecked = false; | |
| } | |
| i++; | |
| } | |
| return allChecked; | |
| } | |
| /* | |
| * Load data from the preference store and configure the UI accordingly. | |
| */ | |
| private void init(IPreferenceStore preferenceStore) | |
| { | |
| /* | |
| * Populate condition maps | |
| */ | |
| ValidationManager validationManager = new ValidationManager(); | |
| for (CheckerDescription checkerDescription : checkersDescriptions) | |
| { | |
| allConditionsMap.put(checkerDescription.getId(), | |
| validationManager.getCheckerConditions(checkerDescription.getId())); | |
| } | |
| String checkersPreference = | |
| preferenceStore.getString(PreflightingUIPlugin.CHECKERS_PREFERENCE_KEY); | |
| // Preference is empty means first time. Perform defaults | |
| if (checkersPreference.length() == 0) | |
| { | |
| performDefaults(); | |
| } | |
| else | |
| { | |
| /* | |
| * Checkers information | |
| */ | |
| if (!checkersPreference.equals(NO_CHECKERS_SELECTED)) //There's checkers to load and check on the table | |
| { | |
| StringTokenizer tokenizer = new StringTokenizer(checkersPreference, ","); //$NON-NLS-1$ | |
| List<CheckerDescription> selectedCheckerDescriptions = | |
| new ArrayList<CheckerDescription>(tokenizer.countTokens()); | |
| while (tokenizer.hasMoreTokens()) | |
| { | |
| String checkerId = tokenizer.nextToken(); | |
| CheckerDescription checkerDescription = getCheckerDescription(checkerId); | |
| if (checkerDescription != null) | |
| { | |
| selectedCheckerDescriptions.add(checkerDescription); | |
| } | |
| } | |
| checkersTableViewer.setCheckedElements(selectedCheckerDescriptions.toArray()); | |
| } | |
| selectAllCheckersCheck.setSelection(areAllItemsChecked(checkersTableViewer)); | |
| String checkersConditionsPreference = | |
| preferenceStore | |
| .getString(PreflightingUIPlugin.CHECKERS_CONDITIONS_PREFERENCE_KEY); | |
| if (checkersConditionsPreference.length() > 0) | |
| { | |
| StringTokenizer tokenizer = new StringTokenizer(checkersConditionsPreference, ";"); | |
| while (tokenizer.hasMoreElements()) | |
| { | |
| String checkerConditionStr = tokenizer.nextToken(); | |
| String[] split = checkerConditionStr.split(":"); | |
| if (split.length == 2) | |
| { | |
| String checkerId = split[0]; | |
| String[] selectedConditionsIds = split[1].split(","); | |
| // define which are the selected conditions | |
| Set<String> selectedConditionsIdsSet = new HashSet<String>(); | |
| for (String selectedConditionId : selectedConditionsIds) | |
| { | |
| selectedConditionsIdsSet.add(selectedConditionId); | |
| } | |
| // get the Condition objects and add them to the selected conditions map | |
| List<Condition> allConditionsList = allConditionsMap.get(checkerId); | |
| List<Condition> selectedConditionsList = new ArrayList<Condition>(); | |
| if (allConditionsList != null) | |
| { | |
| for (Condition condition : allConditionsList) | |
| { | |
| if (selectedConditionsIdsSet.contains(condition.getId())) | |
| { | |
| selectedConditionsList.add(condition); | |
| } | |
| } | |
| } | |
| selectedConditionsMap.put(checkerId, selectedConditionsList); | |
| } | |
| } | |
| } | |
| // create an empty list for the checkers that had no preferences set (new checkers, for example) | |
| for (CheckerDescription checkerDescription : checkersDescriptions) | |
| { | |
| if (selectedConditionsMap.get(checkerDescription.getId()) == null) | |
| { | |
| selectedConditionsMap.put(checkerDescription.getId(), | |
| new ArrayList<Condition>()); | |
| } | |
| } | |
| /* | |
| * Get Extended Properties | |
| */ | |
| // Checker parameters | |
| loadExtendedProperty(checkerParams, preferenceStore, | |
| PreflightingUIPlugin.CHECKERS_PARAMS_PREFERENCE_KEY, String.class); | |
| // Custom checker warning levels | |
| loadExtendedProperty(customCheckersWarningLevels, preferenceStore, | |
| PreflightingUIPlugin.CHECKERS_WARNING_LEVELS_PREFERENCE_KEY, Boolean.class); | |
| // Custom conditions warning levels | |
| loadExtendedProperty(customConditionsWarningLevels, preferenceStore, | |
| PreflightingUIPlugin.CHECKERS_CONDITIONS_WARNING_LEVELS_PREFERENCE_KEY, | |
| Boolean.class); | |
| checkersTableViewer.refresh(); | |
| } | |
| } | |
| /** | |
| * Load saved extend property. The extended properties are related to | |
| * a checker or condition, and are saved in the form: | |
| * <id>,<extended_property>;<id>,<extended_property>... | |
| * | |
| * These properties are loaded in a map <id> -> <extended_property> | |
| * | |
| * @param map the map where the information will be loaded | |
| * @param preferenceStore the preference store | |
| * @param preferenceName the preference key used to store | |
| */ | |
| @SuppressWarnings( | |
| { | |
| "rawtypes", "unchecked" | |
| }) | |
| private void loadExtendedProperty(Map map, IPreferenceStore preferenceStore, | |
| String preferenceName, Class valueType) | |
| { | |
| String preference = preferenceStore.getString(preferenceName); | |
| if (preference.length() > 0) | |
| { | |
| StringTokenizer tokenizer = new StringTokenizer(preference, ";"); | |
| while (tokenizer.hasMoreElements()) | |
| { | |
| String extendedProperty = tokenizer.nextToken(); | |
| String[] split = extendedProperty.split(","); | |
| if (split.length == 2) | |
| { | |
| String id = split[0]; | |
| String params = split[1]; | |
| // string (checker param) | |
| if (valueType.getName().equals("java.lang.String")) | |
| { | |
| map.put(id, params); | |
| } | |
| // boolean (warning levels) | |
| else | |
| { | |
| map.put(id, new Boolean(params)); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * Saved extended properties. The extended properties are related to | |
| * a checker or condition, and are saved in the form: | |
| * <id>,<extended_property>;<id>,<extended_property>... | |
| * | |
| * The properties come from a map <id> -> <extended_property> | |
| * | |
| * @param map a map with the extended properties | |
| * @param preferenceStore the preference store | |
| * @param preferenceName the preference key used to store | |
| */ | |
| private void saveExtendedProperty(Map<String, ?> map, IPreferenceStore preferenceStore, | |
| String preferenceName) | |
| { | |
| StringBuilder stringBuilder = new StringBuilder(); | |
| if (!map.isEmpty()) | |
| { | |
| for (String id : map.keySet()) | |
| { | |
| String params = ((map.get(id) != null) ? map.get(id).toString() : null); | |
| if ((params != null) && (params.length() > 0)) | |
| { | |
| stringBuilder.append(id); | |
| stringBuilder.append(","); //$NON-NLS-1$ | |
| stringBuilder.append(params); | |
| stringBuilder.append(";"); //$NON-NLS-1$ | |
| } | |
| } | |
| deleteLastChar(stringBuilder); | |
| } | |
| preferenceStore.setValue(preferenceName, stringBuilder.toString()); | |
| } | |
| /** | |
| * Get the CheckerDescription object for a fiven checkerId passed as parameter | |
| * | |
| * @param checkerId the checker id of the object to be retrieved | |
| * @return the CheckerDescription object that represents the checker with the id passed as parameter | |
| */ | |
| private CheckerDescription getCheckerDescription(String checkerId) | |
| { | |
| CheckerDescription checkerDescriptionFound = null; | |
| Iterator<CheckerDescription> it = checkersDescriptions.iterator(); | |
| while ((checkerDescriptionFound == null) && it.hasNext()) | |
| { | |
| CheckerDescription checkerDescription = it.next(); | |
| if (checkerDescription.getId().equals(checkerId)) | |
| { | |
| checkerDescriptionFound = checkerDescription; | |
| } | |
| } | |
| return checkerDescriptionFound; | |
| } | |
| /* (non-Javadoc) | |
| * @see com.motorolamobility.preflighting.ui.tabs.AbstractAppValidatorTabComposite#isValid() | |
| */ | |
| @Override | |
| public IStatus isValid() | |
| { | |
| IStatus status = Status.OK_STATUS; | |
| boolean isValid = true; | |
| boolean hasWarning = false; | |
| String msg = ""; | |
| // check if no checker is selected | |
| if (checkersTableViewer.getCheckedElements().length == 0) | |
| { | |
| isValid = false; | |
| msg = PreflightingUiNLS.CheckersTabComposite_Validation_Error_No_Checker; | |
| } | |
| // check if there are parameters for checkers that have custom conditions selection | |
| Object[] checkerDescriptions = checkersTableViewer.getCheckedElements(); | |
| if (checkerDescriptions.length > 0) | |
| { | |
| for (Object checkerDescObj : checkerDescriptions) | |
| { | |
| String checkerId = ((CheckerDescription) checkerDescObj).getId(); | |
| if (((checkerParams.get(checkerId) != null) && !checkerParams.get(checkerId) | |
| .equals(""))) | |
| { | |
| if (hasCustomConditionsSelection(checkerId)) | |
| { | |
| hasWarning = true; | |
| msg = | |
| PreflightingUiNLS.CheckersTabComposite_Validation_Warning_Param_Problem; | |
| } | |
| } | |
| } | |
| } | |
| if (!isValid) | |
| { | |
| status = new Status(IStatus.ERROR, PreflightingUIPlugin.PREFLIGHTING_UI_PLUGIN_ID, msg); | |
| } | |
| else if (hasWarning) | |
| { | |
| status = | |
| new Status(IStatus.WARNING, PreflightingUIPlugin.PREFLIGHTING_UI_PLUGIN_ID, msg); | |
| } | |
| return status; | |
| } | |
| /** | |
| * Check if there are unselected conditions for the checker passed as parameter | |
| * | |
| * @param checkerId the checker to have the conditions selection analysed | |
| * @return true if there is custom selection for the conditions (i.e. unselected conditions), false otherwise | |
| */ | |
| private boolean hasCustomConditionsSelection(String checkerId) | |
| { | |
| boolean result = false; | |
| List<Condition> selectedConditions = selectedConditionsMap.get(checkerId); | |
| if ((selectedConditions != null) | |
| && (selectedConditionsMap.get(checkerId).size() != allConditionsMap.get(checkerId) | |
| .size())) | |
| { | |
| result = true; | |
| } | |
| return result; | |
| } | |
| /* (non-Javadoc) | |
| * @see com.motorolamobility.preflighting.ui.tabs.AbstractAppValidatorTabComposite#performDefaults() | |
| */ | |
| @Override | |
| public void performDefaults() | |
| { | |
| /* | |
| * Checkers - select all | |
| */ | |
| // model / UI | |
| checkersTableViewer.setAllChecked(true); | |
| selectAllCheckersCheck.setSelection(true); | |
| // model | |
| for (CheckerDescription checkerDescription : checkersDescriptions) | |
| { | |
| selectAllConditions(checkerDescription.getId()); | |
| } | |
| // UI | |
| conditionsTableViewer.setAllChecked(true); | |
| selectAllConditionsCheck.setSelection(true); | |
| /* | |
| * Extended Properties | |
| */ | |
| // model | |
| checkerParams.clear(); | |
| customCheckersWarningLevels.clear(); | |
| customConditionsWarningLevels.clear(); | |
| /* | |
| * Update UIs | |
| */ | |
| checkersTableViewer.refresh(); | |
| conditionsTableViewer.refresh(); | |
| } | |
| /* (non-Javadoc) | |
| * @see com.motorolamobility.preflighting.ui.tabs.AbstractAppValidatorTabComposite#performOk(org.eclipse.jface.preference.IPreferenceStore) | |
| */ | |
| @Override | |
| public void performOk(IPreferenceStore preferenceStore) | |
| { | |
| StringBuilder stringBuilder; | |
| /* | |
| * Checkers information | |
| */ | |
| Object[] checkerDescriptions = checkersTableViewer.getCheckedElements(); | |
| stringBuilder = new StringBuilder(); | |
| if (checkerDescriptions.length > 0) | |
| { | |
| for (Object checkerDescObj : checkerDescriptions) | |
| { | |
| CheckerDescription checkerDescription = (CheckerDescription) checkerDescObj; | |
| stringBuilder.append(checkerDescription.getId()); | |
| stringBuilder.append(","); //$NON-NLS-1$ | |
| } | |
| deleteLastChar(stringBuilder); | |
| preferenceStore.putValue(PreflightingUIPlugin.CHECKERS_PREFERENCE_KEY, | |
| stringBuilder.toString()); | |
| } | |
| else | |
| { | |
| preferenceStore.putValue(PreflightingUIPlugin.CHECKERS_PREFERENCE_KEY, | |
| NO_CHECKERS_SELECTED); | |
| } | |
| stringBuilder = new StringBuilder(); | |
| if (!selectedConditionsMap.isEmpty()) | |
| { | |
| for (String checkerId : selectedConditionsMap.keySet()) | |
| { | |
| stringBuilder.append(checkerId); | |
| stringBuilder.append(":"); | |
| for (Condition condition : selectedConditionsMap.get(checkerId)) | |
| { | |
| stringBuilder.append(condition.getId()); | |
| stringBuilder.append(","); //$NON-NLS-1$ | |
| } | |
| deleteLastChar(stringBuilder); | |
| stringBuilder.append(";"); | |
| } | |
| deleteLastChar(stringBuilder); | |
| } | |
| preferenceStore.setValue(PreflightingUIPlugin.CHECKERS_CONDITIONS_PREFERENCE_KEY, | |
| stringBuilder.toString()); | |
| /* | |
| * Extended Properties | |
| */ | |
| // Checker parameters | |
| saveExtendedProperty(checkerParams, preferenceStore, | |
| PreflightingUIPlugin.CHECKERS_PARAMS_PREFERENCE_KEY); | |
| // Custom checker warning levels | |
| saveExtendedProperty(customCheckersWarningLevels, preferenceStore, | |
| PreflightingUIPlugin.CHECKERS_WARNING_LEVELS_PREFERENCE_KEY); | |
| // Custom conditions warning levels | |
| saveExtendedProperty(customConditionsWarningLevels, preferenceStore, | |
| PreflightingUIPlugin.CHECKERS_CONDITIONS_WARNING_LEVELS_PREFERENCE_KEY); | |
| } | |
| /** | |
| * Delete the last char of a string builder | |
| * | |
| * @param stringBuilder the string builder to have the last char deleted | |
| */ | |
| private void deleteLastChar(StringBuilder stringBuilder) | |
| { | |
| if (stringBuilder.length() > 0) | |
| { | |
| stringBuilder.deleteCharAt(stringBuilder.length() - 1); | |
| } | |
| } | |
| /* (non-Javadoc) | |
| * @see com.motorolamobility.preflighting.ui.tabs.AbstractAppValidatorTabComposite#commandLineBuilder() | |
| */ | |
| @Override | |
| public String commandLineBuilder() | |
| { | |
| String commandline = ""; | |
| boolean hasCustomCheckers = !areAllItemsChecked(checkersTableViewer); | |
| boolean hasCustomParameters = hasParameters(); | |
| boolean hasCustomConditions = hasCustomConditions(); | |
| boolean hasCustomWarningLevels = hasCustomWarningLevels(); | |
| // check if there are custom configurations | |
| if (hasCustomCheckers || hasCustomParameters || hasCustomConditions | |
| || hasCustomWarningLevels) | |
| { | |
| Object[] checkedElements = checkersTableViewer.getCheckedElements(); | |
| StringBuilder stringBuilder = new StringBuilder(); | |
| Boolean customWarningLevel = null; | |
| List<String> elementsToIncreaseWarningLevel = new ArrayList<String>(); | |
| List<String> elementsToDecreaseWarningLevel = new ArrayList<String>(); | |
| /* | |
| * Iterate in the selected checkers | |
| */ | |
| for (Object checkedObj : checkedElements) | |
| { | |
| CheckerDescription checkerDescription = (CheckerDescription) checkedObj; | |
| String checkerId = checkerDescription.getId(); | |
| List<Condition> selectedConditions = | |
| ((selectedConditionsMap.get(checkerId) != null) ? selectedConditionsMap | |
| .get(checkerId) : new ArrayList<Condition>()); | |
| // Have custom parameters or there are checkers disabled | |
| // just create the command line block to | |
| // select the checker and to pass the appropriate parameters, if any | |
| if (hasCustomParameters | |
| || (checkedElements.length < checkersTableViewer.getTable().getItems().length)) | |
| { | |
| stringBuilder.append("-c "); | |
| stringBuilder.append(checkerId); | |
| stringBuilder.append(" "); | |
| // params only apply if there are no unselected/custom conditions | |
| String parameters = checkerParams.get(checkerId); | |
| if ((parameters != null) && (parameters.length() > 0)) | |
| { | |
| stringBuilder.append(parameters); | |
| stringBuilder.append(" "); | |
| } | |
| } | |
| // Given that there are conditions disabled, create the command line block | |
| // to enable only the selected ones. Additionally, define the custom warning level | |
| // for that condition, if any | |
| List<Condition> allConditions = allConditionsMap.get(checkerId); | |
| if (allConditions != null) | |
| { | |
| for (Condition condition : allConditions) | |
| { | |
| if ((selectedConditions != null) && !selectedConditions.contains(condition)) | |
| { | |
| //Condition is NOT selected => add it to -dc (disable condition) command | |
| stringBuilder.append("-dc "); | |
| stringBuilder.append(checkerId); | |
| stringBuilder.append("."); | |
| stringBuilder.append(condition.getId()); | |
| stringBuilder.append(" "); | |
| } | |
| } | |
| } | |
| /* | |
| * Build the list of items that must have their warning levels changed | |
| */ | |
| // checker | |
| customWarningLevel = customCheckersWarningLevels.get(checkerId); | |
| if (customWarningLevel != null) | |
| { | |
| if (customWarningLevel) | |
| { | |
| elementsToIncreaseWarningLevel.add(checkerId); | |
| } | |
| else | |
| { | |
| elementsToDecreaseWarningLevel.add(checkerId); | |
| } | |
| } | |
| // conditions | |
| for (Condition condition : ((selectedConditions != null) ? selectedConditions | |
| : allConditionsMap.get(checkerId))) | |
| { | |
| customWarningLevel = customConditionsWarningLevels.get(condition.getId()); | |
| if (customWarningLevel != null) | |
| { | |
| if (customWarningLevel) | |
| { | |
| elementsToIncreaseWarningLevel.add(checkerId + "." + condition.getId()); | |
| } | |
| else | |
| { | |
| elementsToDecreaseWarningLevel.add(checkerId + "." + condition.getId()); | |
| } | |
| } | |
| } | |
| } | |
| /* | |
| * Custom warning levels | |
| */ | |
| stringBuilder.append(createCustomWarningLevelCommandLine(true, | |
| elementsToIncreaseWarningLevel)); | |
| stringBuilder.append(createCustomWarningLevelCommandLine(false, | |
| elementsToDecreaseWarningLevel)); | |
| commandline = stringBuilder.toString().trim(); | |
| } | |
| return commandline; | |
| } | |
| /** | |
| * Create the command line piece which increases or decreases the warning level | |
| * for certain element (checker or condition) | |
| * | |
| * @param increase true if the warning level must be increased, false if it must be decreased, null if the warning level must not change | |
| * @param element the element to have its warning level changed | |
| * @return the command line piece | |
| */ | |
| public String createCustomWarningLevelCommandLine(Boolean increase, List<String> elements) | |
| { | |
| StringBuilder result = new StringBuilder(); | |
| if ((increase != null) && (elements.size() > 0)) | |
| { | |
| if (increase) | |
| { | |
| result.append("-wx"); // increase | |
| } | |
| else | |
| { | |
| result.append("-xw"); // decrease | |
| } | |
| result.append(" "); | |
| for (String element : elements) | |
| { | |
| result.append(element); | |
| result.append(" "); | |
| } | |
| } | |
| return result.toString(); | |
| } | |
| /** | |
| * Check if there are parameters set for any checker | |
| * | |
| * @return true if there are parameters set, false otherwise | |
| */ | |
| private boolean hasParameters() | |
| { | |
| boolean paramsFound = false; | |
| Iterator<String> it = checkerParams.values().iterator(); | |
| while (it.hasNext() && !paramsFound) | |
| { | |
| String checkerParam = it.next(); | |
| if (checkerParam.length() > 0) | |
| { | |
| paramsFound = true; | |
| } | |
| } | |
| return paramsFound; | |
| } | |
| /** | |
| * Check if there are unselected/custom conditions. | |
| * This is used to decide if the App Validator command line must be created or not | |
| * | |
| * @return true if there are custom unselected/custom conditions, false otherwise | |
| */ | |
| private boolean hasCustomConditions() | |
| { | |
| boolean result = false; | |
| for (String checkerId : allConditionsMap.keySet()) | |
| { | |
| List<Condition> selectedConditions = | |
| ((selectedConditionsMap.get(checkerId) != null) ? selectedConditionsMap | |
| .get(checkerId) : new ArrayList<Condition>()); | |
| if (allConditionsMap.get(checkerId).size() != selectedConditions.size()) | |
| { | |
| result = true; | |
| break; | |
| } | |
| } | |
| return result; | |
| } | |
| /** | |
| * Check if there are custom warning levels | |
| * This is used to decide if the App Validator command line must be created or not | |
| * | |
| * @return true if there are custom warning levels, false otherwise | |
| */ | |
| private boolean hasCustomWarningLevels() | |
| { | |
| boolean result = false; | |
| List<Map<String, Boolean>> maps = new ArrayList<Map<String, Boolean>>(); | |
| maps.add(customCheckersWarningLevels); | |
| maps.add(customConditionsWarningLevels); | |
| for (Map<String, Boolean> map : maps) | |
| { | |
| for (Boolean customWarningLevel : map.values()) | |
| { | |
| if (customWarningLevel != null) | |
| { | |
| result = true; | |
| break; | |
| } | |
| } | |
| } | |
| return result; | |
| } | |
| } |