added go to entry feature

10 files changed, 621 insertions, 97 deletions

diff --git a/src/cuchaz/enigma/analysis/SourceIndex.java b/src/cuchaz/enigma/analysis/SourceIndex.java
index 7981f87..ad94cf0 100644
--- a/src/cuchaz/enigma/analysis/SourceIndex.java
+++ b/src/cuchaz/enigma/analysis/SourceIndex.java
@@ -25,12 +25,14 @@ public class SourceIndex
 {
         private String m_source;
         private TreeMap<Token,Entry> m_tokens;
+        private Map<Entry,Token> m_declarations;
         private List<Integer> m_lineOffsets;
         
         public SourceIndex( String source )
         {
                 m_source = source;
                 m_tokens = Maps.newTreeMap();
+                m_declarations = Maps.newHashMap();
                 m_lineOffsets = Lists.newArrayList();
                 
                 // count the lines
@@ -82,9 +84,11 @@ public class SourceIndex
                 m_tokens.put( getToken( node ), entry );
         }
         
-        public void add( Token token, Entry entry )
+        public void addDeclaration( AstNode node, Entry entry )
         {
+                Token token = getToken( node );
                 m_tokens.put( token, entry );
+                m_declarations.put( entry, token );
         }
         
         public Token getToken( int pos )
@@ -116,6 +120,11 @@ public class SourceIndex
                 return m_tokens.keySet();
         }
         
+        public Token getDeclarationToken( Entry entry )
+        {
+                return m_declarations.get( entry );
+        }
+        
         private int toPos( int line, int col )
         {
                 // line and col are 1-based
diff --git a/src/cuchaz/enigma/analysis/SourceIndexVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java
index 5a64e4e..0ba5996 100644
--- a/src/cuchaz/enigma/analysis/SourceIndexVisitor.java
+++ b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java
@@ -16,7 +16,6 @@ import com.strobel.assembler.metadata.MethodDefinition;
 import com.strobel.assembler.metadata.ParameterDefinition;
 import com.strobel.assembler.metadata.TypeDefinition;
 import com.strobel.assembler.metadata.TypeReference;
-import com.strobel.componentmodel.Key;
 import com.strobel.decompiler.languages.TextLocation;
 import com.strobel.decompiler.languages.java.ast.Annotation;
 import com.strobel.decompiler.languages.java.ast.AnonymousObjectCreationExpression;
@@ -149,7 +148,7 @@ public class SourceIndexVisitor implements IAstVisitor<SourceIndex, Void>
                 {
                         ClassEntry classEntry = new ClassEntry( def.getDeclaringType().getInternalName() );
                         MethodEntry methodEntry = new MethodEntry( classEntry, def.getName(), def.getSignature() );
-                        index.add( node.getNameToken(), methodEntry );
+                        index.addDeclaration( node.getNameToken(), methodEntry );
                 }
                 
                 return recurse( node, index );
@@ -172,7 +171,7 @@ public class SourceIndexVisitor implements IAstVisitor<SourceIndex, Void>
                 MethodDefinition methodDef = (MethodDefinition)def.getMethod();
                 MethodEntry methodEntry = new MethodEntry( classEntry, methodDef.getName(), methodDef.getSignature() );
                 ArgumentEntry argumentEntry = new ArgumentEntry( methodEntry, def.getPosition(), def.getName() );
-                index.add( node.getNameToken(), argumentEntry );
+                index.addDeclaration( node.getNameToken(), argumentEntry );
                 
                 return recurse( node, index );
         }
@@ -185,7 +184,7 @@ public class SourceIndexVisitor implements IAstVisitor<SourceIndex, Void>
                 FieldEntry fieldEntry = new FieldEntry( classEntry, def.getName() );
                 assert( node.getVariables().size() == 1 );
                 VariableInitializer variable = node.getVariables().firstOrNullObject();
-                index.add( variable.getNameToken(), fieldEntry );
+                index.addDeclaration( variable.getNameToken(), fieldEntry );
                 
                 return recurse( node, index );
         }
@@ -194,16 +193,13 @@ public class SourceIndexVisitor implements IAstVisitor<SourceIndex, Void>
         public Void visitTypeDeclaration( TypeDeclaration node, SourceIndex index )
         {
                 TypeDefinition def = node.getUserData( Keys.TYPE_DEFINITION );
-                index.add( node.getNameToken(), new ClassEntry( def.getInternalName() ) );
+                index.addDeclaration( node.getNameToken(), new ClassEntry( def.getInternalName() ) );
                 
                 return recurse( node, index );
         }
         
         private Void recurse( AstNode node, SourceIndex index )
         {
-                // TEMP: show the tree
-                System.out.println( getIndent( node ) + node.getClass().getSimpleName() + dumpUserData( node ) + " " + node.getRegion() );
-                
                 for( final AstNode child : node.getChildren() )
                 {
                         child.acceptVisitor( this, index );
@@ -211,42 +207,6 @@ public class SourceIndexVisitor implements IAstVisitor<SourceIndex, Void>
                 return null;
         }
         
-        private String dumpUserData( AstNode node )
-        {
-                StringBuilder buf = new StringBuilder();
-                for( Key<?> key : Keys.ALL_KEYS )
-                {
-                        Object val = node.getUserData( key );
-                        if( val != null )
-                        {
-                                buf.append( String.format( " [%s=%s]", key, val ) );
-                        }
-                }
-                return buf.toString();
-        }
-        
-        private String getIndent( AstNode node )
-        {
-                StringBuilder buf = new StringBuilder();
-                int depth = getDepth( node );
-                for( int i = 0; i < depth; i++ )
-                {
-                        buf.append( "\t" );
-                }
-                return buf.toString();
-        }
-        
-        private int getDepth( AstNode node )
-        {
-                int depth = -1;
-                while( node != null )
-                {
-                        depth++;
-                        node = node.getParent();
-                }
-                return depth;
-        }
-        
         // OVERRIDES WE DON'T CARE ABOUT
         
         @Override
diff --git a/src/cuchaz/enigma/analysis/TreeDumpVisitor.java b/src/cuchaz/enigma/analysis/TreeDumpVisitor.java
new file mode 100644
index 0000000..32607db
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/TreeDumpVisitor.java
@@ -0,0 +1,550 @@
+package cuchaz.enigma.analysis;
+
+import com.strobel.componentmodel.Key;
+import com.strobel.decompiler.languages.java.ast.Annotation;
+import com.strobel.decompiler.languages.java.ast.AnonymousObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ArrayCreationExpression;
+import com.strobel.decompiler.languages.java.ast.ArrayInitializerExpression;
+import com.strobel.decompiler.languages.java.ast.ArraySpecifier;
+import com.strobel.decompiler.languages.java.ast.AssertStatement;
+import com.strobel.decompiler.languages.java.ast.AssignmentExpression;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.BinaryOperatorExpression;
+import com.strobel.decompiler.languages.java.ast.BlockStatement;
+import com.strobel.decompiler.languages.java.ast.BreakStatement;
+import com.strobel.decompiler.languages.java.ast.CaseLabel;
+import com.strobel.decompiler.languages.java.ast.CastExpression;
+import com.strobel.decompiler.languages.java.ast.CatchClause;
+import com.strobel.decompiler.languages.java.ast.ClassOfExpression;
+import com.strobel.decompiler.languages.java.ast.Comment;
+import com.strobel.decompiler.languages.java.ast.CompilationUnit;
+import com.strobel.decompiler.languages.java.ast.ComposedType;
+import com.strobel.decompiler.languages.java.ast.ConditionalExpression;
+import com.strobel.decompiler.languages.java.ast.ConstructorDeclaration;
+import com.strobel.decompiler.languages.java.ast.ContinueStatement;
+import com.strobel.decompiler.languages.java.ast.DoWhileStatement;
+import com.strobel.decompiler.languages.java.ast.EmptyStatement;
+import com.strobel.decompiler.languages.java.ast.EnumValueDeclaration;
+import com.strobel.decompiler.languages.java.ast.ExpressionStatement;
+import com.strobel.decompiler.languages.java.ast.FieldDeclaration;
+import com.strobel.decompiler.languages.java.ast.ForEachStatement;
+import com.strobel.decompiler.languages.java.ast.ForStatement;
+import com.strobel.decompiler.languages.java.ast.GotoStatement;
+import com.strobel.decompiler.languages.java.ast.IAstVisitor;
+import com.strobel.decompiler.languages.java.ast.Identifier;
+import com.strobel.decompiler.languages.java.ast.IdentifierExpression;
+import com.strobel.decompiler.languages.java.ast.IfElseStatement;
+import com.strobel.decompiler.languages.java.ast.ImportDeclaration;
+import com.strobel.decompiler.languages.java.ast.IndexerExpression;
+import com.strobel.decompiler.languages.java.ast.InstanceInitializer;
+import com.strobel.decompiler.languages.java.ast.InstanceOfExpression;
+import com.strobel.decompiler.languages.java.ast.InvocationExpression;
+import com.strobel.decompiler.languages.java.ast.JavaTokenNode;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.LabelStatement;
+import com.strobel.decompiler.languages.java.ast.LabeledStatement;
+import com.strobel.decompiler.languages.java.ast.LambdaExpression;
+import com.strobel.decompiler.languages.java.ast.LocalTypeDeclarationStatement;
+import com.strobel.decompiler.languages.java.ast.MemberReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.MethodDeclaration;
+import com.strobel.decompiler.languages.java.ast.MethodGroupExpression;
+import com.strobel.decompiler.languages.java.ast.NewLineNode;
+import com.strobel.decompiler.languages.java.ast.NullReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ObjectCreationExpression;
+import com.strobel.decompiler.languages.java.ast.PackageDeclaration;
+import com.strobel.decompiler.languages.java.ast.ParameterDeclaration;
+import com.strobel.decompiler.languages.java.ast.ParenthesizedExpression;
+import com.strobel.decompiler.languages.java.ast.PrimitiveExpression;
+import com.strobel.decompiler.languages.java.ast.ReturnStatement;
+import com.strobel.decompiler.languages.java.ast.SimpleType;
+import com.strobel.decompiler.languages.java.ast.SuperReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.SwitchSection;
+import com.strobel.decompiler.languages.java.ast.SwitchStatement;
+import com.strobel.decompiler.languages.java.ast.SynchronizedStatement;
+import com.strobel.decompiler.languages.java.ast.TextNode;
+import com.strobel.decompiler.languages.java.ast.ThisReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.ThrowStatement;
+import com.strobel.decompiler.languages.java.ast.TryCatchStatement;
+import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
+import com.strobel.decompiler.languages.java.ast.TypeParameterDeclaration;
+import com.strobel.decompiler.languages.java.ast.TypeReferenceExpression;
+import com.strobel.decompiler.languages.java.ast.UnaryOperatorExpression;
+import com.strobel.decompiler.languages.java.ast.VariableDeclarationStatement;
+import com.strobel.decompiler.languages.java.ast.VariableInitializer;
+import com.strobel.decompiler.languages.java.ast.WhileStatement;
+import com.strobel.decompiler.languages.java.ast.WildcardType;
+import com.strobel.decompiler.patterns.Pattern;
+
+public class TreeDumpVisitor implements IAstVisitor<Void, Void>
+{
+        private Void recurse( AstNode node, Void ignored )
+        {
+                // show the tree
+                System.out.println( getIndent( node ) + node.getClass().getSimpleName() + dumpUserData( node ) + " " + node.getRegion() );
+                
+                // recurse
+                for( final AstNode child : node.getChildren() )
+                {
+                        child.acceptVisitor( this, ignored );
+                }
+                return null;
+        }
+        
+        private String dumpUserData( AstNode node )
+        {
+                StringBuilder buf = new StringBuilder();
+                for( Key<?> key : Keys.ALL_KEYS )
+                {
+                        Object val = node.getUserData( key );
+                        if( val != null )
+                        {
+                                buf.append( String.format( " [%s=%s]", key, val ) );
+                        }
+                }
+                return buf.toString();
+        }
+        
+        private String getIndent( AstNode node )
+        {
+                StringBuilder buf = new StringBuilder();
+                int depth = getDepth( node );
+                for( int i = 0; i < depth; i++ )
+                {
+                        buf.append( "\t" );
+                }
+                return buf.toString();
+        }
+        
+        private int getDepth( AstNode node )
+        {
+                int depth = -1;
+                while( node != null )
+                {
+                        depth++;
+                        node = node.getParent();
+                }
+                return depth;
+        }
+        
+        // OVERRIDES WE DON'T CARE ABOUT
+        
+        @Override
+        public Void visitInvocationExpression( InvocationExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitMemberReferenceExpression( MemberReferenceExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitSimpleType( SimpleType node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitMethodDeclaration( MethodDeclaration node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitConstructorDeclaration( ConstructorDeclaration node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitParameterDeclaration( ParameterDeclaration node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitFieldDeclaration( FieldDeclaration node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitTypeDeclaration( TypeDeclaration node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitComment( Comment node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitPatternPlaceholder( AstNode node, Pattern pattern, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitTypeReference( TypeReferenceExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitJavaTokenNode( JavaTokenNode node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitIdentifier( Identifier node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitNullReferenceExpression( NullReferenceExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitThisReferenceExpression( ThisReferenceExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitSuperReferenceExpression( SuperReferenceExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitClassOfExpression( ClassOfExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitBlockStatement( BlockStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitExpressionStatement( ExpressionStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitBreakStatement( BreakStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitContinueStatement( ContinueStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitDoWhileStatement( DoWhileStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitEmptyStatement( EmptyStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitIfElseStatement( IfElseStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitLabelStatement( LabelStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitLabeledStatement( LabeledStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitReturnStatement( ReturnStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitSwitchStatement( SwitchStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitSwitchSection( SwitchSection node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitCaseLabel( CaseLabel node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitThrowStatement( ThrowStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitCatchClause( CatchClause node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitAnnotation( Annotation node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitNewLine( NewLineNode node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitVariableDeclaration( VariableDeclarationStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitVariableInitializer( VariableInitializer node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitText( TextNode node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitImportDeclaration( ImportDeclaration node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitInitializerBlock( InstanceInitializer node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitTypeParameterDeclaration( TypeParameterDeclaration node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitCompilationUnit( CompilationUnit node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitPackageDeclaration( PackageDeclaration node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitArraySpecifier( ArraySpecifier node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitComposedType( ComposedType node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitWhileStatement( WhileStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitPrimitiveExpression( PrimitiveExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitCastExpression( CastExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitBinaryOperatorExpression( BinaryOperatorExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitInstanceOfExpression( InstanceOfExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitIndexerExpression( IndexerExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitIdentifierExpression( IdentifierExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitUnaryOperatorExpression( UnaryOperatorExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitConditionalExpression( ConditionalExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitArrayInitializerExpression( ArrayInitializerExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitObjectCreationExpression( ObjectCreationExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitArrayCreationExpression( ArrayCreationExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitAssignmentExpression( AssignmentExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitForStatement( ForStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitForEachStatement( ForEachStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitTryCatchStatement( TryCatchStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitGotoStatement( GotoStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitParenthesizedExpression( ParenthesizedExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitSynchronizedStatement( SynchronizedStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitAnonymousObjectCreationExpression( AnonymousObjectCreationExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitWildcardType( WildcardType node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitMethodGroupExpression( MethodGroupExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitEnumValueDeclaration( EnumValueDeclaration node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitAssertStatement( AssertStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitLambdaExpression( LambdaExpression node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+        
+        @Override
+        public Void visitLocalTypeDeclarationStatement( LocalTypeDeclarationStatement node, Void ignored )
+        {
+                return recurse( node, ignored );
+        }
+}
diff --git a/src/cuchaz/enigma/gui/Gui.java b/src/cuchaz/enigma/gui/Gui.java
index 79becf8..bf72c85 100644
--- a/src/cuchaz/enigma/gui/Gui.java
+++ b/src/cuchaz/enigma/gui/Gui.java
@@ -63,7 +63,6 @@ import javax.swing.tree.TreeNode;
 import javax.swing.tree.TreePath;
 
 import jsyntaxpane.DefaultSyntaxKit;
-import jsyntaxpane.SyntaxDocument;
 
 import com.google.common.collect.Lists;
 
@@ -257,6 +256,10 @@ public class Gui
                                                 startRename();
                                         break;
                                         
+                                        case KeyEvent.VK_I:
+                                                showInheritance();
+                                        break;
+                                        
                                         case KeyEvent.VK_O:
                                                 openEntry();
                                         break;
@@ -296,10 +299,11 @@ public class Gui
                                 }
                         } );
                         popupMenu.add( menu );
+                        menu.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_I, 0 ) );
                         m_inheritanceMenu = menu;
                 }
                 {
-                        JMenuItem menu = new JMenuItem( "Open Class" );
+                        JMenuItem menu = new JMenuItem( "Go to Declaration" );
                         menu.addActionListener( new ActionListener( )
                         {
                                 @Override
@@ -598,34 +602,13 @@ public class Gui
         
         public void setSource( String source )
         {
-                setSource( source, 0 );
+                m_editor.getHighlighter().removeAllHighlights();
+                m_editor.setText( source );
         }
         
-        public void setSource( String source, int lineNum )
+        public void showToken( Token token )
         {
-                // remove any old highlighters
-                m_editor.getHighlighter().removeAllHighlights();
-                
-                m_editor.setText( source );
-                
-                // count the offset of the target line
-                String text = m_editor.getText();
-                int pos = 0;
-                int numLines = 0;
-                for( ; pos < text.length(); pos++ )
-                {
-                        if( numLines == lineNum )
-                        {
-                                break;
-                        }
-                        if( text.charAt( pos ) == '\n' )
-                        {
-                                numLines++;
-                        }
-                }
-                
-                // put the caret at the line number
-                m_editor.setCaretPosition( pos );
+                m_editor.setCaretPosition( token.start );
                 m_editor.grabFocus();
         }
         
@@ -760,12 +743,13 @@ public class Gui
                 
                 m_selectedEntryPair = m_controller.getEntryPair( token );
                 boolean isClassEntry = m_selectedEntryPair.obf instanceof ClassEntry;
+                boolean isFieldEntry = m_selectedEntryPair.obf instanceof FieldEntry;
                 boolean isMethodEntry = m_selectedEntryPair.obf instanceof MethodEntry;
                 
                 showEntryPair( m_selectedEntryPair );
                 
                 m_inheritanceMenu.setEnabled( isClassEntry || isMethodEntry );
-                m_openEntryMenu.setEnabled( isClassEntry );
+                m_openEntryMenu.setEnabled( isClassEntry || isFieldEntry || isMethodEntry );
         }
         
         private void startRename( )
@@ -807,12 +791,9 @@ public class Gui
                 String newName = text.getText();
                 if( saveName && newName != null && newName.length() > 0 )
                 {
-                        SyntaxDocument doc = (SyntaxDocument)m_editor.getDocument();
-                        int lineNum = doc.getLineNumberAt( m_editor.getCaretPosition() );
                         try
                         {
-                                // TODO: give token to the controller so we can put the caret back there
-                                m_controller.rename( m_selectedEntryPair.obf, newName, lineNum );
+                                m_controller.rename( m_selectedEntryPair.obf, newName );
                         }
                         catch( IllegalNameException ex )
                         {
@@ -869,12 +850,7 @@ public class Gui
                 {
                         return;
                 }
-                
-                // get the current class
-                if( m_selectedEntryPair.obf instanceof ClassEntry )
-                {
-                        m_controller.deobfuscateClass( new ClassFile( m_selectedEntryPair.obf.getName() ) );
-                }
+                m_controller.openEntry( m_selectedEntryPair.obf );
         }
         
         private void close( )
diff --git a/src/cuchaz/enigma/gui/GuiController.java b/src/cuchaz/enigma/gui/GuiController.java
index e0aad86..834afec 100644
--- a/src/cuchaz/enigma/gui/GuiController.java
+++ b/src/cuchaz/enigma/gui/GuiController.java
@@ -77,7 +77,7 @@ public class GuiController
                 m_isDirty = false;
                 m_gui.setMappingsFile( file );
                 refreshClasses();
-                refreshOpenFiles();
+                refreshCurrentClass();
         }
 
         public void saveMappings( File file )
@@ -94,7 +94,7 @@ public class GuiController
                 m_deobfuscator.setMappings( null );
                 m_gui.setMappingsFile( null );
                 refreshClasses();
-                refreshOpenFiles();
+                refreshCurrentClass();
         }
         
         public void deobfuscateClass( ClassFile classFile )
@@ -157,12 +157,26 @@ public class GuiController
                 return thisNode;
         }
         
-        public void rename( Entry obfsEntry, String newName, int lineNum )
+        public void rename( Entry obfEntry, String newName )
         {
-                m_deobfuscator.rename( obfsEntry, newName );
+                m_deobfuscator.rename( obfEntry, newName );
                 m_isDirty = true;
                 refreshClasses();
-                refreshOpenFiles( lineNum );
+                refreshCurrentClass( m_deobfuscator.deobfuscateEntry( obfEntry ) );
+        }
+        
+        public void openEntry( Entry obfEntry )
+        {
+                Entry deobfEntry = m_deobfuscator.deobfuscateEntry( obfEntry );
+                if( !m_currentFile.getName().equals( obfEntry.getClassName() ) )
+                {
+                        m_currentFile = new ClassFile( obfEntry.getClassName() );
+                        deobfuscate( m_currentFile, deobfEntry );
+                }
+                else
+                {
+                        m_gui.showToken( m_index.getDeclarationToken( deobfEntry ) );
+                }
         }
         
         private void refreshClasses( )
@@ -173,27 +187,28 @@ public class GuiController
                 m_gui.setObfClasses( obfClasses );
                 m_gui.setDeobfClasses( deobfClasses );
         }
-
-        private void refreshOpenFiles( )
+        
+        private void refreshCurrentClass( )
         {
-                refreshOpenFiles( 0 );
+                refreshCurrentClass( null );
         }
         
-        private void refreshOpenFiles( int lineNum )
+        private void refreshCurrentClass( Entry entryToShow )
         {
                 if( m_currentFile != null )
                 {
-                        deobfuscate( m_currentFile, lineNum );
+                        deobfuscate( m_currentFile, entryToShow );
                 }
         }
 
         private void deobfuscate( final ClassFile classFile )
         {
-                deobfuscate( classFile, 0 );
+                deobfuscate( classFile, null );
         }
         
-        private void deobfuscate( final ClassFile classFile, final int lineNum )
+        private void deobfuscate( final ClassFile classFile, final Entry entryToShow )
         {
+                m_currentFile = classFile;
                 m_gui.setSource( "(deobfuscating...)" );
                 
                 // run the deobfuscator in a separate thread so we don't block the GUI event queue
@@ -202,9 +217,13 @@ public class GuiController
                         @Override
                         public void run( )
                         {
-                                // decopmile,deobfuscate the bytecode
+                                // decompile,deobfuscate the bytecode
                                 m_index = m_deobfuscator.getSource( classFile );
-                                m_gui.setSource( m_index.getSource(), lineNum );
+                                m_gui.setSource( m_index.getSource() );
+                                if( entryToShow != null )
+                                {
+                                        m_gui.showToken( m_index.getDeclarationToken( entryToShow ) );
+                                }
                                 
                                 // set the highlighted tokens
                                 List<Token> obfuscatedTokens = Lists.newArrayList();
diff --git a/src/cuchaz/enigma/mapping/ArgumentEntry.java b/src/cuchaz/enigma/mapping/ArgumentEntry.java
index c1624a8..0c25c4d 100644
--- a/src/cuchaz/enigma/mapping/ArgumentEntry.java
+++ b/src/cuchaz/enigma/mapping/ArgumentEntry.java
@@ -70,6 +70,7 @@ public class ArgumentEntry implements Entry, Serializable
                 return m_methodEntry.getClassEntry();
         }
         
+        @Override
         public String getClassName( )
         {
                 return m_methodEntry.getClassName();
diff --git a/src/cuchaz/enigma/mapping/ClassEntry.java b/src/cuchaz/enigma/mapping/ClassEntry.java
index 0968e95..513862d 100644
--- a/src/cuchaz/enigma/mapping/ClassEntry.java
+++ b/src/cuchaz/enigma/mapping/ClassEntry.java
@@ -45,6 +45,12 @@ public class ClassEntry implements Entry, Serializable
         }
         
         @Override
+        public String getClassName( )
+        {
+                return m_name;
+        }
+        
+        @Override
         public int hashCode( )
         {
                 return m_name.hashCode();
diff --git a/src/cuchaz/enigma/mapping/Entry.java b/src/cuchaz/enigma/mapping/Entry.java
index 1443532..3ff8027 100644
--- a/src/cuchaz/enigma/mapping/Entry.java
+++ b/src/cuchaz/enigma/mapping/Entry.java
@@ -13,4 +13,5 @@ package cuchaz.enigma.mapping;
 public interface Entry
 {
         String getName( );
+        String getClassName( );
 }
diff --git a/src/cuchaz/enigma/mapping/FieldEntry.java b/src/cuchaz/enigma/mapping/FieldEntry.java
index eefc4c4..6148c84 100644
--- a/src/cuchaz/enigma/mapping/FieldEntry.java
+++ b/src/cuchaz/enigma/mapping/FieldEntry.java
@@ -60,6 +60,7 @@ public class FieldEntry implements Entry, Serializable
                 return m_name;
         }
         
+        @Override
         public String getClassName( )
         {
                 return m_classEntry.getName();
diff --git a/src/cuchaz/enigma/mapping/MethodEntry.java b/src/cuchaz/enigma/mapping/MethodEntry.java
index 9ea2d08..ff232c5 100644
--- a/src/cuchaz/enigma/mapping/MethodEntry.java
+++ b/src/cuchaz/enigma/mapping/MethodEntry.java
@@ -72,6 +72,7 @@ public class MethodEntry implements Entry, Serializable
                 return m_signature;
         }
         
+        @Override
         public String getClassName( )
         {
                 return m_classEntry.getName();