SelectRepositoryPage.java

package com.proalpha.pds.gitutils.mylyn;
 
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.Collections;
 
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.egit.ui.internal.repository.RepositoriesViewContentProvider;
import org.eclipse.egit.ui.internal.repository.RepositoryTreeNodeLabelProvider;
import org.eclipse.egit.ui.internal.repository.tree.RepositoryNode;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.errors.NoWorkTreeException;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Text;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.pds.gitutils.Activator;
 
@SuppressWarnings("restriction")
public class SelectRepositoryPage extends WizardPage {
 
    private final Logger logger = LoggerFactory.getLogger(SelectRepositoryPage.class);
    private FeatureBranchSettings settings;
    private RepositoryFilter searchFilter;
    private CheckboxTableViewer repositoryViewer;
    private ICheckStateListener checkRepositoryStateListener;
    private Button showAllProjectsButton;
 
    public SelectRepositoryPage(FeatureBranchSettings settings) {
        super(SelectRepositoryPage.class.getName());
 
        this.settings = settings;
 
        setTitle("Repository Selection");
        setMessage("If no repository is selected, the task will be activated without repository action.", INFORMATION);
        setDescription("Desc Select the repository");
 
        URL url = FileLocator.find(Platform.getBundle(Activator.PLUGIN_ID), new Path("icons/pA-logox72.png"),
                Collections.emptyMap());
 
        setImageDescriptor(ImageDescriptor.createFromURL(url));
        searchFilter = new RepositoryFilter(settings.getTask());
    }
 
    private void createFilterText(Group repositoryGroup) {
 
        Text filterText = new Text(repositoryGroup, SWT.SEARCH | SWT.ICON_SEARCH | SWT.CANCEL | SWT.ICON_CANCEL);
        filterText.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL));
        filterText.setMessage("type to filter the repositories shown");
        filterText.addModifyListener(new ModifyListener() {
 
            @Override
            public void modifyText(ModifyEvent event) {
                searchFilter.setSearchText(filterText.getText());
 
                RepositoryNode activeRepositoryNode = getActiveRepositoryNode();
                repositoryViewer.refresh();
                // clear selection if repository is no longer visible
                checkIfRepositoryStillInView(activeRepositoryNode);
            }
        });
    }
 
    private RepositoryNode getActiveRepositoryNode() {
        RepositoryNode returnValue = null;
        Object[] activeRepositoryNodes = repositoryViewer.getCheckedElements();
 
        // activeRepositoryNodes is either of length 0 or 1 since there can only be one
        // activated repository
        if (activeRepositoryNodes.length > 0) {
            returnValue = (RepositoryNode) activeRepositoryNodes[0];
        }
 
        return returnValue;
    }
 
    private void checkIfRepositoryStillInView(RepositoryNode activeRepositoryNode) {
 
        if (activeRepositoryNode != null) {
            for (TableItem item : repositoryViewer.getTable().getItems()) {
                if (item.getData().equals(activeRepositoryNode)) {
                    return;
                }
            }
            setNoRepositorySelected();
        }
    }
 
    private void createButtonShowAllProjects(Group repositoryGroup) {
        showAllProjectsButton = new Button(repositoryGroup, SWT.CHECK);
        showAllProjectsButton.setText("Show all Repositories");
        showAllProjectsButton.addSelectionListener(new SelectionListener() {
 
            @Override
            public void widgetSelected(SelectionEvent event) {
                searchFilter.setShowAllProjects(((Button) event.widget).getSelection());
                RepositoryNode activeRepositoryNode = getActiveRepositoryNode();
                repositoryViewer.refresh();
                // clear selection if repository is no longer visible
                checkIfRepositoryStillInView(activeRepositoryNode);
            }
 
            @Override
            public void widgetDefaultSelected(SelectionEvent arg0) {
 
            }
        });
    }
 
    @Override
    public void createControl(Composite parent) {
 
        Composite container = new Composite(parent, SWT.NULL);
        container.setLayout(new GridLayout(1, false));
 
        Group repositoryGroup = new Group(container, SWT.NONE);
        repositoryGroup.setText("Repositories");
        repositoryGroup.setBackgroundMode(SWT.INHERIT_DEFAULT);
 
        createFilterText(repositoryGroup);
        createButtonShowAllProjects(repositoryGroup);
 
        GridDataFactory.fillDefaults().grab(true, true).span(2, 1).applyTo(repositoryGroup);
        GridLayoutFactory.swtDefaults().numColumns(1).applyTo(repositoryGroup);
 
        repositoryViewer = CheckboxTableViewer.newCheckList(repositoryGroup,
                SWT.SINGLE | SWT.V_SCROLL | SWT.H_SCROLL | SWT.BORDER);
        repositoryViewer.setLabelProvider(new RepositoryTreeNodeLabelProvider());
        repositoryViewer.setContentProvider(new RepositoriesViewContentProvider());
        repositoryViewer.setInput(ResourcesPlugin.getWorkspace().getRoot());
        repositoryViewer.addFilter(searchFilter);
        showAllProjectsButton.setSelection(true);
        showAllProjectsButton.notifyListeners(SWT.Selection, null);
        checkRepositoryStateListener = new CheckRepositoryStateListener();
 
        repositoryViewer.addCheckStateListener(checkRepositoryStateListener);
        GridDataFactory.fillDefaults().grab(true, true).hint(SWT.DEFAULT, 40).applyTo(repositoryViewer.getControl());
 
        if (repositoryViewer.getTable().getItems().length == 1) {
            checkRepositoryStateListener.checkStateChanged(
                    new CheckStateChangedEvent(repositoryViewer, repositoryViewer.getElementAt(0), true));
        }
 
        setPageComplete(true);
        setControl(container);
    }
 
    private void setNoRepositorySelected() {
        setMessage(
                "If no local repository is selected, then only the task will be active but no repository action will be performed!",
                INFORMATION);
        settings.setRepository(null);
        setPageComplete(true);
    }
 
    public class CheckRepositoryStateListener implements ICheckStateListener {
 
        boolean clean;
 
        @Override
        public void checkStateChanged(CheckStateChangedEvent event) {
            clean = true;
 
            if (event.getChecked()) {
                Repository rep = ((RepositoryNode) event.getElement()).getRepository();
 
                settings.setRepository(rep);
                settings.setDbCommit(Activator.fetchDbCommit(rep));
                settings.setArtifactsCommit(Activator.fetchArtifactsCommit(rep));
                repositoryViewer.setAllChecked(false);
                repositoryViewer.setChecked(event.getElement(), true);
 
                try (Git git = new Git(rep)) {
                    // isClean() also reports false if there are untracked files
                    // --> this is possibly "too clean". It is sufficient to check
                    // if there are tracked files which chaned
                    setMessage("Check repository status...", INFORMATION);
 
                    getContainer().run(true, false, new IRunnableWithProgress() {
                        public void run(IProgressMonitor monitor) {
                            try {
                                clean = git.status().call().getUncommittedChanges().isEmpty();
 
                            } catch (NoWorkTreeException | GitAPIException e) {
                                logger.error("Error while trying to get the state of the repository", e);
                            }
 
                        }
                    });
                } catch (InvocationTargetException e) {
                    logger.error(e.getMessage(), e);
                } catch (InterruptedException e) {
                    logger.error(e.getMessage(), e);
                    Thread.currentThread().interrupt();
                }
 
                if (!clean) {
                    MessageDialog.openError(getShell(), "Dirty workspace",
                            "The workspace of this repository is dirty. You have to commit, "
                                    + "stash, or undo your changes before you can create a new branch "
                                    + "in this repository.");
                    setPageComplete(false);
                } else {
                    setPageComplete(rep != null);
                    settings.deriveDefaults();
                    setMessage("");
 
                }
            } else {
                setNoRepositorySelected();
            }
        }
    }
 
    @Override
    public boolean canFlipToNextPage() {
        if (settings.getRepository() != null) {
            return super.canFlipToNextPage();
        }
        return false;
    }
}