Capturing Eclipse Java Editor events

CaptureEvents.java

import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
import org.eclipse.jdt.ui.IWorkingCopyManager;
import org.eclipse.jface.text.ITextViewerExtension5;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.viewers.IPostSelectionProvider;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IWorkbenchPart;

/*
 * This class allows you to capture Eclipse Java Editor events, can also be used to 
 * capture other types of editor events. This listener register for the editor
 * window when it becomes active and unregisters previous editor listeners. 
 * The Entry point has been labelled (selectionChanged) and from that method you
 * capture the IJavaElement which I use to parse to get an Eclipse AST.
 */
public class CaptureEvents implements ISelectionChangedListener, IPartListener {
	  
   @SuppressWarnings("restriction")
   JavaEditor editor; //it is an internal func, so it may change from ver to ver
  	
   ISelectionProvider selectionProvider;
   IJavaElement last;
   int lastCaret;

   @SuppressWarnings("restriction")
   public void register(JavaEditor part) {
      unregister();
      editor = part;
      selectionProvider = editor.getSelectionProvider();
      if (selectionProvider != null) {
         if (selectionProvider instanceof IPostSelectionProvider) {
            IPostSelectionProvider provider = (IPostSelectionProvider) selectionProvider;
            provider.addPostSelectionChangedListener(this);
         } else {
            selectionProvider.addSelectionChangedListener(this);
         }
      }
   }

   public void unregister() {
      if (selectionProvider != null) {
         selectionProvider.removeSelectionChangedListener(this);
      }

      selectionProvider = null;
      editor = null;
   }

   /**
    * Entry point for handling each change event.
    */
   public void selectionChanged(SelectionChangedEvent event) {
      ISourceViewer sourceViewer = editor.getViewer();
      if (sourceViewer == null) return;

      StyledText styledText = sourceViewer.getTextWidget();
      if (styledText == null) return;

      int caret = getCaretPosition(sourceViewer, styledText);
      this.lastCaret = caret;

      IWorkingCopyManager manager = JavaPlugin.getDefault().getWorkingCopyManager();
      ICompilationUnit unit = manager.getWorkingCopy(editor.getEditorInput());
  
      if (unit == null) return;
      ASTNode node = parse(unit);
  		
      //At this point you have an AST and caret position go nuts
   }
  	
  	

    public ASTNode parse(ICompilationUnit comp) {
      ASTParser parser = ASTParser.newParser(AST.JLS3);
      parser.setResolveBindings(true);
      parser.setSource(comp);
      return  parser.createAST(null);
    }

  
   boolean isDeclaration(IJavaElement element) {
      return element != null && (element.getElementType() == IJavaElement.FIELD ||
           element.getElementType() == IJavaElement.METHOD ||
           element.getElementType() == IJavaElement.TYPE);
   }
  	
  

   protected static IJavaElement getElementAt(ICompilationUnit unit, int offset,
  			boolean reconcile) throws JavaModelException {
      if (reconcile) {
         synchronized (unit) {
            unit.reconcile(ICompilationUnit.NO_AST, false, null, null);
         }
  			
         return unit.getElementAt(offset);
      } else if (unit.isConsistent())
         return unit.getElementAt(offset);

      return null;
   }

   int getCaretPosition(ISourceViewer sourceViewer, StyledText styledText) {
      if (sourceViewer instanceof ITextViewerExtension5) {
         ITextViewerExtension5 extension = (ITextViewerExtension5) sourceViewer;
         return extension.widgetOffset2ModelOffset(styledText.getCaretOffset());
      } else {
         int offset = sourceViewer.getVisibleRegion().getOffset();
         return offset + styledText.getCaretOffset();
      }
   }

   @SuppressWarnings("restriction")
   public void partActivated(IWorkbenchPart part) {
      if (part instanceof JavaEditor) {
         register((JavaEditor)part);
      }
   }
  	
   // Required methods of IPartListener
   public void partBroughtToTop(IWorkbenchPart part) {}
   public void partClosed(IWorkbenchPart part) {}
   public void partDeactivated(IWorkbenchPart part) {}
   public void partOpened(IWorkbenchPart part) {}
}