source: default/trunk/de.ugoe.cs.swe.bnftools.ebnf.ui/src/de/ugoe/cs/swe/bnftools/ui/refactoring/inlinetokenrules/InlineTokenRulesRefactoringHandler.java @ 18

package de.ugoe.cs.swe.bnftools.ui.refactoring.inlinetokenrules;

import java.util.ArrayList;
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.emf.ecore.EObject;
import org.eclipse.ltk.ui.refactoring.RefactoringWizard;
import org.eclipse.ltk.ui.refactoring.RefactoringWizardOpenOperation;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;
import org.eclipse.xtext.parsetree.AbstractNode;
import org.eclipse.xtext.parsetree.CompositeNode;
import org.eclipse.xtext.parsetree.NodeAdapter;
import org.eclipse.xtext.parsetree.NodeUtil;
import org.eclipse.xtext.resource.IResourceDescriptions;
import org.eclipse.xtext.ui.editor.XtextEditor;
import org.eclipse.xtext.ui.editor.model.XtextDocument;

import com.google.inject.Inject;

import de.ugoe.cs.swe.bnftools.analysis.EbnfAnalysisUtils;
import de.ugoe.cs.swe.bnftools.ebnf.BnfEntry;
import de.ugoe.cs.swe.bnftools.ebnf.Rule;
import de.ugoe.cs.swe.bnftools.ui.refactoring.generic.GenericRefactoring;
import de.ugoe.cs.swe.bnftools.ui.refactoring.generic.GenericRefactoringWizard;
import de.ugoe.cs.swe.bnftools.utils.DeclarationReferencesPair;
import de.ugoe.cs.swe.bnftools.utils.RootEObjectFinder;
import de.ugoe.cs.swe.bnftools.utils.Utils;

public class InlineTokenRulesRefactoringHandler extends AbstractHandler {

        @Inject
        IResourceDescriptions resourceDescriptions;

        public Object execute(ExecutionEvent event) throws ExecutionException {
                XtextEditor editor = (XtextEditor) PlatformUI.getWorkbench()
                .getActiveWorkbenchWindow().getActivePage().getActiveEditor();

//TODO: better error handling           
                if (!(editor.getDocument() instanceof XtextDocument)) {
                        return null;
                }
                
                XtextDocument doc = (XtextDocument) editor.getDocument();
                EObject root = doc.readOnly(new RootEObjectFinder());
                NodeAdapter rootNode = NodeUtil.getNodeAdapter(root);
                
                List<DeclarationReferencesPair> nodePairs = new ArrayList<DeclarationReferencesPair>();
                for (int i=0; i < rootNode.getParserNode().getChildren().size(); i++) {
                        AbstractNode currentNode = rootNode.getParserNode().getChildren().get(i);

                        EObject element = currentNode.getElement();
                        if (!(element instanceof BnfEntry))
                                continue;
                        BnfEntry bnfEntry = (BnfEntry) element;
                        if (bnfEntry.getRule() == null)
                                continue;
                        
                        currentNode = NodeUtil.getNodeAdapter(bnfEntry.getRule()).getParserNode();

                        if (currentNode.getElement() instanceof Rule) {
                                Rule rule = (Rule) currentNode.getElement();
                                NodeAdapter declarationNode = NodeUtil.getNodeAdapter(rule);
                                if (EbnfAnalysisUtils.isTokenRule(rule)) {
                                        List<CompositeNode> references = Utils.findReferences(rule,
                                                        resourceDescriptions, editor);
                                        
                                        DeclarationReferencesPair nodePair = new DeclarationReferencesPair(declarationNode.getParserNode(), references);
                                        nodePairs.add(nodePair);
                                }
                        }
                }
                
                InlineTokenRulesRefactoringProcessor processor = new InlineTokenRulesRefactoringProcessor(
                                editor, rootNode.getParserNode(), doc, nodePairs);

                GenericRefactoring refactoring = new GenericRefactoring(processor);
                
                GenericRefactoringWizard wizard = new GenericRefactoringWizard(
                                refactoring, RefactoringWizard.WIZARD_BASED_USER_INTERFACE);

                RefactoringWizardOpenOperation openOperation = new RefactoringWizardOpenOperation(
                                wizard);

                try {
                        openOperation.run(Display.getCurrent().getActiveShell(),
                                        "Refactoring not possible!");
                } catch (InterruptedException e1) {
                        e1.printStackTrace();
                }
                return null;
        }

}