org.eclipse.equinox.internal.p2.ui.dialogs.RemediationGroup.java Source code

Java tutorial

Introduction

Here is the source code for org.eclipse.equinox.internal.p2.ui.dialogs.RemediationGroup.java

Source

/*******************************************************************************
 * Copyright (c) 2013 Red Hat, Inc. and others
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 *  Contributors:
 *     Red Hat, Inc. - initial API and implementation
 *******************************************************************************/
package org.eclipse.equinox.internal.p2.ui.dialogs;

import java.util.*;
import java.util.List;
import org.eclipse.equinox.internal.p2.ui.*;
import org.eclipse.equinox.internal.p2.ui.model.*;
import org.eclipse.equinox.p2.metadata.IInstallableUnit;
import org.eclipse.equinox.p2.metadata.Version;
import org.eclipse.equinox.p2.operations.*;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.*;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StackLayout;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.*;

public class RemediationGroup {
    final int ALLOWPARTIALINSTALL_INDEX = 0;
    final int ALLOWDIFFERENTVERSION_INDEX = 1;
    final int ALLOWINSTALLEDUPDATE_INDEX = 2;
    final int ALLOWINSTALLEDREMOVAL_INDEX = 3;

    private RemediationOperation remediationOperation;
    Composite remediationComposite;
    private Button bestBeingInstalledRelaxedButton;
    private Button bestInstalledRelaxedButton;
    Button buildMyOwnSolution;
    final ArrayList<Button> checkboxes = new ArrayList<Button>();
    private Composite resultFoundComposite;
    private Composite resultComposite;
    private Composite resultNotFoundComposite;
    private Composite resultErrorComposite;
    private Remedy currentRemedy;

    private TreeViewer treeViewer;
    private TreeViewerComparator treeComparator;
    protected IUElementListRoot input;
    private StackLayout switchRemediationLayout;
    Group detailsControl;
    Text detailStatusText;
    Composite checkBoxesComposite;
    private IUDetailsGroup iuDetailsGroup;

    HashMap<String, String[]> CONSTRAINTS;
    private WizardPage containerPage;

    public class RemedyContentProvider implements ITreeContentProvider {

        public void dispose() {
            // not needed
        }

        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
            // not needed
        }

        public Object[] getElements(Object inputElement) {
            Object[] elements = ElementUtils.requestToRemedyElementsCategories((Remedy) inputElement);
            return elements;
        }

        public Object[] getChildren(Object parentElement) {
            if (parentElement instanceof RemedyElementCategory) {
                RemedyElementCategory category = (RemedyElementCategory) parentElement;
                return category.getElements().toArray();
            }
            return null;
        }

        public Object getParent(Object element) {
            return null;
        }

        public boolean hasChildren(Object element) {
            if (element instanceof RemedyElementCategory) {
                return true;
            }
            return false;
        }
    }

    public RemediationGroup(WizardPage page) {
        CONSTRAINTS = new HashMap<String, String[]>();
        CONSTRAINTS.put(ProvUIMessages.RemediationPage_BeingInstalledSection,
                new String[] { ProvUIMessages.RemediationPage_BeingInstalledSection_AllowPartialInstall,
                        ProvUIMessages.RemediationPage_BeingInstalledSection_AllowDifferentVersion });
        CONSTRAINTS.put(ProvUIMessages.RemediationPage_InstalledSection,
                new String[] { ProvUIMessages.RemediationPage_InstalledSection_AllowInstalledUpdate,
                        ProvUIMessages.RemediationPage_InstalledSection_AllowInstalledRemoval });

        containerPage = page;
    }

    public Composite getComposite() {
        return remediationComposite;
    }

    public void createRemediationControl(Composite container) {
        remediationComposite = new Composite(container, SWT.NONE);
        remediationComposite.setLayout(new GridLayout());
        Listener solutionslistener;

        Label descriptionLabel = new Label(remediationComposite, SWT.NONE);
        descriptionLabel.setText(ProvUIMessages.RemediationPage_SubDescription);

        solutionslistener = new Listener() {
            public void handleEvent(Event e) {
                Button btn = (Button) e.widget;
                Remedy remedy = (btn.getData() == null ? null : (Remedy) btn.getData());
                checkboxes.get(ALLOWPARTIALINSTALL_INDEX)
                        .setSelection(remedy != null && remedy.getConfig().allowPartialInstall);
                checkboxes.get(ALLOWDIFFERENTVERSION_INDEX)
                        .setSelection(remedy != null && remedy.getConfig().allowDifferentVersion);
                checkboxes.get(ALLOWINSTALLEDUPDATE_INDEX)
                        .setSelection(remedy != null && remedy.getConfig().allowInstalledUpdate);
                checkboxes.get(ALLOWINSTALLEDREMOVAL_INDEX)
                        .setSelection(remedy != null && remedy.getConfig().allowInstalledRemoval);
                for (Iterator<Button> iterator = checkboxes.iterator(); iterator.hasNext();) {
                    Button btn1 = iterator.next();
                    btn1.setVisible(true);
                }
                if (btn == buildMyOwnSolution && btn.getSelection()) {
                    checkBoxesComposite.setVisible(true);
                    ((GridData) checkBoxesComposite.getLayoutData()).exclude = false;
                } else {
                    checkBoxesComposite.setVisible(false);
                    ((GridData) checkBoxesComposite.getLayoutData()).exclude = true;
                }
                currentRemedy = searchRemedyMatchingUserChoices();
                refreshResultComposite();
                remediationComposite.layout(false);
            }
        };

        bestBeingInstalledRelaxedButton = new Button(remediationComposite, SWT.RADIO);
        bestBeingInstalledRelaxedButton.setText(ProvUIMessages.RemediationPage_BestSolutionBeingInstalledRelaxed);
        bestBeingInstalledRelaxedButton.addListener(SWT.Selection, solutionslistener);

        bestInstalledRelaxedButton = new Button(remediationComposite, SWT.RADIO);
        bestInstalledRelaxedButton.setText(ProvUIMessages.RemediationPage_BestSolutionInstallationRelaxed);
        bestInstalledRelaxedButton.addListener(SWT.Selection, solutionslistener);

        buildMyOwnSolution = new Button(remediationComposite, SWT.RADIO);
        buildMyOwnSolution.setText(ProvUIMessages.RemediationPage_BestSolutionBuilt);
        buildMyOwnSolution.addListener(SWT.Selection, solutionslistener);

        Listener checkboxListener = new Listener() {
            public void handleEvent(Event e) {
                currentRemedy = searchRemedyMatchingUserChoices();
                refreshResultComposite();
            }
        };
        checkBoxesComposite = new Composite(remediationComposite, SWT.NONE);
        checkBoxesComposite.setLayout(new GridLayout(1, false));
        GridData data = new GridData();
        data.exclude = false;
        data.horizontalAlignment = SWT.FILL;
        checkBoxesComposite.setLayoutData(data);

        GridData gd = new GridData(SWT.FILL, SWT.FILL, true, false);
        gd.horizontalIndent = 30;
        Iterator<String> iter = CONSTRAINTS.keySet().iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            String[] values = CONSTRAINTS.get(key);
            for (String value : values) {
                Button checkBtn = new Button(checkBoxesComposite, SWT.CHECK);
                checkBtn.setText(value);
                checkBtn.setData(value);
                checkBtn.setLayoutData(gd);
                checkBtn.addListener(SWT.Selection, checkboxListener);
                checkboxes.add(checkBtn);
            }

        }

        resultComposite = new Composite(remediationComposite, SWT.NONE);
        // GridLayoutFactory.fillDefaults().numColumns(1).applyTo(resultComposite);
        switchRemediationLayout = new StackLayout();
        resultComposite.setLayout(switchRemediationLayout);
        GridData data1 = new GridData(GridData.FILL_BOTH);
        resultComposite.setLayoutData(data1);

        resultErrorComposite = new Composite(resultComposite, SWT.NONE);
        resultErrorComposite.setLayout(new GridLayout());
        resultErrorComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

        resultNotFoundComposite = new Composite(resultComposite, SWT.NONE);
        resultNotFoundComposite.setLayout(new GridLayout());
        Label resultNotFoundLabel = new Label(resultNotFoundComposite, SWT.NONE);
        resultNotFoundLabel.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
        resultNotFoundLabel.setText(ProvUIMessages.RemediationPage_NoSolutionFound);

        resultFoundComposite = new Composite(resultComposite, SWT.NONE);
        resultFoundComposite.setLayout(new GridLayout());

        Group insideFoundComposite = new Group(resultFoundComposite, SWT.NONE);
        insideFoundComposite.setText(ProvUIMessages.RemediationPage_SolutionDetails);
        GridLayout gridLayout = new GridLayout();
        gridLayout.marginWidth = 0;
        gridLayout.marginHeight = 0;
        insideFoundComposite.setLayout(gridLayout);
        insideFoundComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

        treeViewer = new TreeViewer(insideFoundComposite, SWT.BORDER | SWT.MULTI | SWT.FULL_SELECTION);
        ColumnViewerToolTipSupport.enableFor(treeViewer);
        data = new GridData(GridData.FILL_BOTH);
        Tree tree = treeViewer.getTree();
        tree.setLayoutData(data);
        tree.setHeaderVisible(true);
        TreeViewerColumn nameColumn = new TreeViewerColumn(treeViewer, SWT.LEFT);
        nameColumn.getColumn().setText(ProvUIMessages.ProvUI_NameColumnTitle);
        nameColumn.getColumn().setWidth(400);
        nameColumn.getColumn().setMoveable(true);
        nameColumn.getColumn().addSelectionListener(columnChangeListener(0));
        nameColumn.setLabelProvider(new ColumnLabelProvider() {
            public String getText(Object element) {
                if (element instanceof RemedyElementCategory)
                    return ((RemedyElementCategory) element).getName();
                if (element instanceof RemedyIUDetail) {
                    RemedyIUDetail iu = (RemedyIUDetail) element;
                    String label = iu.getIu().getProperty(IInstallableUnit.PROP_NAME, null);
                    if (label == null)
                        label = iu.getIu().getId();
                    return label;
                }
                return super.getText(element);
            }

            public Image getImage(Object element) {
                if (element instanceof RemedyElementCategory) {
                    RemedyElementCategory category = (RemedyElementCategory) element;
                    if (category.getName().equals(ProvUIMessages.RemedyCategoryAdded))
                        return ProvUIImages.getImage(ProvUIImages.IMG_ADDED);
                    if (category.getName().equals(ProvUIMessages.RemedyCategoryChanged))
                        return ProvUIImages.getImage(ProvUIImages.IMG_CHANGED);
                    if (category.getName().equals(ProvUIMessages.RemedyCategoryNotAdded))
                        return ProvUIImages.getImage(ProvUIImages.IMG_NOTADDED);
                    if (category.getName().equals(ProvUIMessages.RemedyCategoryRemoved))
                        return ProvUIImages.getImage(ProvUIImages.IMG_REMOVED);
                } else if (element instanceof RemedyIUDetail) {
                    RemedyIUDetail iuDetail = (RemedyIUDetail) element;
                    int status = compare(iuDetail);
                    if (compare(iuDetail.getBeingInstalledVersion(), iuDetail.getRequestedVersion()) < 0
                            && containerPage != null && containerPage.getWizard() instanceof UpdateWizard) {
                        Image img = ProvUIImages.getImage(ProvUIImages.IMG_UPGRADED_IU);
                        ImageDescriptor overlay = ProvUIActivator.getDefault().getImageRegistry()
                                .getDescriptor(ProvUIImages.IMG_INFO);
                        String decoratedImageId = ProvUIImages.IMG_UPGRADED_IU.concat(ProvUIImages.IMG_INFO);
                        if (ProvUIActivator.getDefault().getImageRegistry().get(decoratedImageId) == null) {
                            DecorationOverlayIcon decoratedImage = new DecorationOverlayIcon(img, overlay,
                                    IDecoration.BOTTOM_RIGHT);
                            ProvUIActivator.getDefault().getImageRegistry().put(decoratedImageId, decoratedImage);
                        }
                        Image decoratedImg = ProvUIActivator.getDefault().getImageRegistry().get(decoratedImageId);
                        return decoratedImg;
                    }

                    if (status < 0)
                        return ProvUIImages.getImage(ProvUIImages.IMG_DOWNGRADED_IU);
                    if (status > 0)
                        return ProvUIImages.getImage(ProvUIImages.IMG_UPGRADED_IU);
                    return ProvUIImages.getImage(ProvUIImages.IMG_IU);
                }
                return super.getImage(element);
            }

            public String getToolTipText(Object element) {
                if (element instanceof RemedyIUDetail) {
                    RemedyIUDetail iuDetail = (RemedyIUDetail) element;
                    String toolTipText = ""; //$NON-NLS-1$
                    List<String> versions = new ArrayList<String>();
                    if (iuDetail.getInstalledVersion() != null)
                        versions.add(ProvUIMessages.RemedyElementInstalledVersion
                                + iuDetail.getInstalledVersion().toString());
                    if (iuDetail.getRequestedVersion() != null)
                        versions.add(ProvUIMessages.RemedyElementRequestedVersion
                                + iuDetail.getRequestedVersion().toString());
                    if (iuDetail.getBeingInstalledVersion() != null)
                        versions.add(ProvUIMessages.RemedyElementBeingInstalledVersion
                                + iuDetail.getBeingInstalledVersion().toString());
                    for (Iterator<String> iterator = versions.iterator(); iterator.hasNext();) {
                        String version = iterator.next();
                        toolTipText += (toolTipText == "" ? "" : "\n") + version; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
                    }
                    if (containerPage != null && containerPage.getWizard() instanceof UpdateWizard
                            && compare(iuDetail.getBeingInstalledVersion(), iuDetail.getRequestedVersion()) < 0)
                        toolTipText = ProvUIMessages.RemedyElementNotHighestVersion + "\n\n" + toolTipText; //$NON-NLS-1$
                    return toolTipText;
                }
                return super.getToolTipText(element);
            }

            private int compare(Version versionA, Version versionB) {
                if (versionA != null && versionB != null)
                    return versionA.compareTo(versionB);
                return 0;
            }

            private int compare(RemedyIUDetail iuDetail) {
                if (iuDetail.getStatus() == RemedyIUDetail.STATUS_ADDED && iuDetail.getRequestedVersion() != null
                        && iuDetail.getBeingInstalledVersion() != null) {
                    return compare(iuDetail.getBeingInstalledVersion(), iuDetail.getRequestedVersion());
                }
                if (iuDetail.getStatus() == RemedyIUDetail.STATUS_CHANGED && iuDetail.getInstalledVersion() != null
                        && iuDetail.getBeingInstalledVersion() != null) {
                    return compare(iuDetail.getBeingInstalledVersion(), iuDetail.getInstalledVersion());
                }
                return 0;
            }
        });
        TreeViewerColumn versionColumn = new TreeViewerColumn(treeViewer, SWT.LEFT);
        versionColumn.getColumn().setText(ProvUIMessages.ProvUI_VersionColumnTitle);
        versionColumn.getColumn().setWidth(200);
        versionColumn.getColumn().addSelectionListener(columnChangeListener(1));
        versionColumn.setLabelProvider(new ColumnLabelProvider() {
            public String getText(Object element) {
                if (element instanceof RemedyIUDetail) {
                    RemedyIUDetail iu = (RemedyIUDetail) element;
                    if (iu.getBeingInstalledVersion() != null)
                        return iu.getBeingInstalledVersion().toString();
                }
                return ""; //$NON-NLS-1$
            }
        });
        TreeViewerColumn idColumn = new TreeViewerColumn(treeViewer, SWT.LEFT);
        idColumn.getColumn().setText(ProvUIMessages.ProvUI_IdColumnTitle);
        idColumn.getColumn().setWidth(200);
        idColumn.getColumn().addSelectionListener(columnChangeListener(2));

        idColumn.setLabelProvider(new ColumnLabelProvider() {
            public String getText(Object element) {
                if (element instanceof RemedyIUDetail) {
                    RemedyIUDetail iu = (RemedyIUDetail) element;
                    return iu.getIu().getId();
                }
                return ""; //$NON-NLS-1$
            }
        });

        treeComparator = new TreeViewerComparator();
        treeViewer.setComparator(treeComparator);
        treeViewer.setContentProvider(new RemedyContentProvider());
        treeViewer.setAutoExpandLevel(2);
        iuDetailsGroup = new IUDetailsGroup(resultErrorComposite, treeViewer, 500, true);
    }

    public IUDetailsGroup getDetailsGroup() {
        return iuDetailsGroup;
    }

    private Remedy searchBestDefaultRemedy() {
        if (remediationOperation.bestSolutionChangingTheRequest() != null) {
            return remediationOperation.bestSolutionChangingTheRequest();
        }
        if (remediationOperation.bestSolutionChangingWhatIsInstalled() != null) {
            return remediationOperation.bestSolutionChangingWhatIsInstalled();
        }
        return remediationOperation.getRemedies().get(0);
    }

    public void update(RemediationOperation operation) {
        this.remediationOperation = operation;
        currentRemedy = searchBestDefaultRemedy();

        bestBeingInstalledRelaxedButton.setData(remediationOperation.bestSolutionChangingTheRequest());
        bestInstalledRelaxedButton.setData(remediationOperation.bestSolutionChangingWhatIsInstalled());

        bestBeingInstalledRelaxedButton.setEnabled(remediationOperation.bestSolutionChangingTheRequest() != null);
        bestInstalledRelaxedButton.setEnabled(remediationOperation.bestSolutionChangingWhatIsInstalled() != null);
        bestBeingInstalledRelaxedButton.setSelection(false);
        bestInstalledRelaxedButton.setSelection(false);
        buildMyOwnSolution.setSelection(false);

        if (currentRemedy == remediationOperation.bestSolutionChangingTheRequest()) {
            bestBeingInstalledRelaxedButton.setSelection(true);
            bestBeingInstalledRelaxedButton.notifyListeners(SWT.Selection, new Event());
        } else if (currentRemedy == remediationOperation.bestSolutionChangingWhatIsInstalled()) {
            bestInstalledRelaxedButton.setSelection(true);
            bestInstalledRelaxedButton.notifyListeners(SWT.Selection, new Event());
        } else {
            buildMyOwnSolution.setData(currentRemedy);
            buildMyOwnSolution.setSelection(true);
            buildMyOwnSolution.notifyListeners(SWT.Selection, new Event());
        }
    }

    private boolean isContraintOK(int btnIndex, boolean value) {
        return (checkboxes.get(btnIndex).getSelection() && value)
                || (!checkboxes.get(btnIndex).getSelection() && !value);
    }

    Remedy searchRemedyMatchingUserChoices() {
        List<Remedy> remedies = remediationOperation.getRemedies();
        for (Remedy remedy : remedies) {
            if (isContraintOK(ALLOWPARTIALINSTALL_INDEX, remedy.getConfig().allowPartialInstall)
                    && isContraintOK(ALLOWDIFFERENTVERSION_INDEX, remedy.getConfig().allowDifferentVersion)
                    && isContraintOK(ALLOWINSTALLEDUPDATE_INDEX, remedy.getConfig().allowInstalledUpdate)
                    && isContraintOK(ALLOWINSTALLEDREMOVAL_INDEX, remedy.getConfig().allowInstalledRemoval)) {
                if (remedy.getRequest() != null) {
                    return remedy;
                }
            }
        }
        return null;
    }

    void refreshResultComposite() {
        resultComposite.setVisible(true);
        if (!checkboxes.get(ALLOWPARTIALINSTALL_INDEX).getSelection()
                && !checkboxes.get(ALLOWDIFFERENTVERSION_INDEX).getSelection()
                && !checkboxes.get(ALLOWINSTALLEDUPDATE_INDEX).getSelection()
                && !checkboxes.get(ALLOWINSTALLEDREMOVAL_INDEX).getSelection()) {
            switchRemediationLayout.topControl = resultErrorComposite;
        } else {

            if (currentRemedy == null) {
                switchRemediationLayout.topControl = resultNotFoundComposite;
            } else {
                if (currentRemedy.getIusDetails().size() == 0) {
                    switchRemediationLayout.topControl = resultNotFoundComposite;
                } else {
                    treeViewer.setInput(currentRemedy);
                    switchRemediationLayout.topControl = resultFoundComposite;
                }
            }
        }
        resultComposite.layout();
        containerPage.setPageComplete(currentRemedy != null);
    }

    public Remedy getCurrentRemedy() {
        return currentRemedy;
    }

    public String getMessage() {
        return ProvUIMessages.InstallRemediationPage_Description;
    }

    class TreeViewerComparator extends ViewerComparator {
        private int sortColumn = 0;
        private int ascending = 1;

        @SuppressWarnings("unchecked")
        @Override
        public int compare(Viewer viewer1, Object e1, Object e2) {
            if (!(e1 instanceof RemedyIUDetail && e2 instanceof RemedyIUDetail))
                return 0;
            IInstallableUnit iu1 = ((RemedyIUDetail) e1).getIu();
            IInstallableUnit iu2 = ((RemedyIUDetail) e2).getIu();
            if (iu1 != null && iu2 != null) {
                if (viewer1 instanceof TreeViewer) {
                    TreeViewer theTreeViewer = (TreeViewer) viewer1;
                    ColumnLabelProvider labelProvider = (ColumnLabelProvider) theTreeViewer
                            .getLabelProvider(sortColumn);
                    String e1p = labelProvider.getText(e1);
                    String e2p = labelProvider.getText(e2);
                    return ascending * getComparator().compare(e1p, e2p);
                }
                return 0;
            }
            return super.compare(viewer1, e1, e2);
        }

        public void setSortColumn(int sortColumn) {
            this.sortColumn = sortColumn;
        }

        public int getSortColumn() {
            return sortColumn;
        }

        public boolean isAscending() {
            return ascending == 1 ? true : false;
        }

        public void setAscending(boolean asc) {
            this.ascending = asc ? 1 : -1;
        }
    }

    private SelectionAdapter columnChangeListener(final int index) {
        return new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                updateTableSorting(index);
            }
        };
    }

    private void updateTableSorting(int columnIndex) {
        TreeViewerComparator comparator = (TreeViewerComparator) treeViewer.getComparator();
        // toggle direction if it's the same column
        if (columnIndex == treeComparator.getSortColumn()) {
            comparator.setAscending(!treeComparator.isAscending());
        }
        comparator.setSortColumn(columnIndex);
        treeViewer.getTree().setSortColumn(treeViewer.getTree().getColumn(columnIndex));
        treeViewer.getTree().setSortDirection(comparator.isAscending() ? SWT.UP : SWT.DOWN);
        treeViewer.refresh(false);
        treeViewer.expandToLevel(2);
    }

}