diff options
Diffstat (limited to 'src/plugins/preflighting.ui/src/com/motorolamobility/preflighting/ui/tabs/CheckersTabComposite.java')
| -rw-r--r-- | src/plugins/preflighting.ui/src/com/motorolamobility/preflighting/ui/tabs/CheckersTabComposite.java | 1755 |
1 files changed, 1755 insertions, 0 deletions
diff --git a/src/plugins/preflighting.ui/src/com/motorolamobility/preflighting/ui/tabs/CheckersTabComposite.java b/src/plugins/preflighting.ui/src/com/motorolamobility/preflighting/ui/tabs/CheckersTabComposite.java new file mode 100644 index 0000000..ff5e5b1 --- /dev/null +++ b/src/plugins/preflighting.ui/src/com/motorolamobility/preflighting/ui/tabs/CheckersTabComposite.java @@ -0,0 +1,1755 @@ +/*
+* 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;
+ }
+}
|