CherryPickHandler.java

package com.proalpha.pds.gitutils.cherrypick;
 
import java.util.Collections;
import java.util.List;
 
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.expressions.IEvaluationContext;
import org.eclipse.egit.ui.internal.repository.tree.RepositoryTreeNode;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.ISources;
import org.eclipse.ui.handlers.HandlerUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
@SuppressWarnings("restriction")
public class CherryPickHandler<T extends RepositoryTreeNode<?>> extends AbstractHandler {
 
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
    private IEvaluationContext evaluationContext;
 
    @Override
    public Object execute(ExecutionEvent event) throws ExecutionException {
 
        RepositoryTreeNode<?> treenode = (RepositoryTreeNode<?>) getSelectedNodes(event).get(0);
 
        Repository repository = treenode.getRepository();
        CherryPickWizard wizz = new CherryPickWizard(repository);
        WizardDialog wdl = new WizardDialog(getShell(event), wizz);
        if (wdl.open() == Window.OK) {
            logger.debug("Ok pressed");
        } else {
            logger.debug("Cancel pressed");
        }
 
        return null;
    }
 
    @SuppressWarnings("unchecked")
    protected List<T> getSelectedRepo() {
        if (evaluationContext != null) {
            Object selection = evaluationContext.getVariable(ISources.ACTIVE_MENU_SELECTION_NAME);
            if (selection == null || !(selection instanceof IStructuredSelection))
                selection = evaluationContext.getVariable(ISources.ACTIVE_CURRENT_SELECTION_NAME);
            if (selection instanceof IStructuredSelection) {
                return ((IStructuredSelection) selection).toList();
            }
        }
        return null;
    }
 
    @SuppressWarnings("unchecked")
    public List<T> getSelectedNodes(ExecutionEvent event)
            throws ExecutionException {
        ISelection selection = HandlerUtil.getCurrentSelectionChecked(event);
        if (selection instanceof IStructuredSelection)
            return ((IStructuredSelection) selection).toList();
        else
            return Collections.emptyList();
    }
    
    public Shell getShell(ExecutionEvent event) {
        return HandlerUtil.getActiveShell(event);
    }
 
    @Override
    public void setEnabled(Object evaluationContext) {
        if (evaluationContext instanceof IEvaluationContext)
            this.evaluationContext = (IEvaluationContext) evaluationContext;
        else
            this.evaluationContext = null;
    }
 
}