19 files changed, 397 insertions, 82 deletions

diff --git a/build.gradle b/build.gradle
index 3dfbae41..8b0a2c50 100644
--- a/build.gradle
+++ b/build.gradle
@@ -24,7 +24,7 @@ subprojects {
     }
 
     group = 'cuchaz'
-    version = '0.21.8'
+    version = '0.22.0'
 
     version = version + (System.getenv("GITHUB_ACTIONS") ? "" : "+local")
 
diff --git a/enigma-swing/src/main/java/cuchaz/enigma/gui/ClassSelector.java b/enigma-swing/src/main/java/cuchaz/enigma/gui/ClassSelector.java
index 488d04ed..b27832be 100644
--- a/enigma-swing/src/main/java/cuchaz/enigma/gui/ClassSelector.java
+++ b/enigma-swing/src/main/java/cuchaz/enigma/gui/ClassSelector.java
@@ -27,6 +27,7 @@ import com.google.common.collect.Maps;
 import com.google.common.collect.Multimap;
 import cuchaz.enigma.gui.node.ClassSelectorClassNode;
 import cuchaz.enigma.gui.node.ClassSelectorPackageNode;
+import cuchaz.enigma.gui.util.GuiUtil;
 import cuchaz.enigma.translation.Translator;
 import cuchaz.enigma.translation.representation.entry.ClassEntry;
 import cuchaz.enigma.utils.validation.ValidationContext;
@@ -69,10 +70,13 @@ public class ClassSelector extends JTree {
                         }
                 });
 
+                final DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();
+                renderer.setLeafIcon(GuiUtil.CLASS_ICON);
+                setCellRenderer(renderer);
+
                 final JTree tree = this;
 
-                final DefaultTreeCellEditor editor = new DefaultTreeCellEditor(tree,
-                                (DefaultTreeCellRenderer) tree.getCellRenderer()) {
+                final DefaultTreeCellEditor editor = new DefaultTreeCellEditor(tree, renderer) {
                         @Override
                         public boolean isCellEditable(EventObject event) {
                                 return isRenamable && !(event instanceof MouseEvent) && super.isCellEditable(event);
diff --git a/enigma-swing/src/main/java/cuchaz/enigma/gui/Gui.java b/enigma-swing/src/main/java/cuchaz/enigma/gui/Gui.java
index c56731dc..d74fefd9 100644
--- a/enigma-swing/src/main/java/cuchaz/enigma/gui/Gui.java
+++ b/enigma-swing/src/main/java/cuchaz/enigma/gui/Gui.java
@@ -51,10 +51,7 @@ import cuchaz.enigma.network.packet.RemoveMappingC2SPacket;
 import cuchaz.enigma.network.packet.RenameC2SPacket;
 import cuchaz.enigma.source.Token;
 import cuchaz.enigma.translation.mapping.EntryRemapper;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-import cuchaz.enigma.translation.representation.entry.Entry;
-import cuchaz.enigma.translation.representation.entry.FieldEntry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
+import cuchaz.enigma.translation.representation.entry.*;
 import cuchaz.enigma.utils.I18n;
 import cuchaz.enigma.utils.validation.ParameterizedMessage;
 import cuchaz.enigma.utils.validation.ValidationContext;
@@ -82,6 +79,7 @@ public class Gui implements LanguageChangeListener {
         private JPanel classesPanel;
         private JSplitPane splitClasses;
         private IdentifierPanel infoPanel;
+        private StructurePanel structurePanel;
         private JTree inheritanceTree;
         private JTree implementationsTree;
         private JTree callsTree;
@@ -163,13 +161,17 @@ public class Gui implements LanguageChangeListener {
                 // init info panel
                 infoPanel = new IdentifierPanel(this);
 
+                // init structure panel
+                this.structurePanel = new StructurePanel(this);
+
                 // init inheritance panel
                 inheritanceTree = new JTree();
                 inheritanceTree.setModel(null);
+                inheritanceTree.setShowsRootHandles(true);
                 inheritanceTree.addMouseListener(new MouseAdapter() {
                         @Override
                         public void mouseClicked(MouseEvent event) {
-                                if (event.getClickCount() >= 2) {
+                                if (event.getClickCount() >= 2 && event.getButton() == MouseEvent.BUTTON1) {
                                         // get the selected node
                                         TreePath path = inheritanceTree.getSelectionPath();
                                         if (path == null) {
@@ -199,10 +201,11 @@ public class Gui implements LanguageChangeListener {
                 // init implementations panel
                 implementationsTree = new JTree();
                 implementationsTree.setModel(null);
+                implementationsTree.setShowsRootHandles(true);
                 implementationsTree.addMouseListener(new MouseAdapter() {
                         @Override
                         public void mouseClicked(MouseEvent event) {
-                                if (event.getClickCount() >= 2) {
+                                if (event.getClickCount() >= 2 && event.getButton() == MouseEvent.BUTTON1) {
                                         // get the selected node
                                         TreePath path = implementationsTree.getSelectionPath();
                                         if (path == null) {
@@ -227,11 +230,12 @@ public class Gui implements LanguageChangeListener {
                 // init call panel
                 callsTree = new JTree();
                 callsTree.setModel(null);
+                callsTree.setShowsRootHandles(true);
                 callsTree.addMouseListener(new MouseAdapter() {
                         @SuppressWarnings("unchecked")
                         @Override
                         public void mouseClicked(MouseEvent event) {
-                                if (event.getClickCount() >= 2) {
+                                if (event.getClickCount() >= 2 && event.getButton() == MouseEvent.BUTTON1) {
                                         // get the selected node
                                         TreePath path = callsTree.getSelectionPath();
                                         if (path == null) {
@@ -287,6 +291,8 @@ public class Gui implements LanguageChangeListener {
                                                 editorTabPopupMenu.show(openFiles, e.getX(), e.getY(), EditorPanel.byUi(openFiles.getComponentAt(i)));
                                         }
                                 }
+
+                                showStructure(getActiveEditor());
                         }
                 });
 
@@ -311,6 +317,7 @@ public class Gui implements LanguageChangeListener {
                 centerPanel.add(openFiles, BorderLayout.CENTER);
                 tabs = new JTabbedPane();
                 tabs.setPreferredSize(ScaleUtil.getDimension(250, 0));
+                tabs.addTab(I18n.translate("info_panel.tree.structure"), structurePanel);
                 tabs.addTab(I18n.translate("info_panel.tree.inheritance"), inheritancePanel);
                 tabs.addTab(I18n.translate("info_panel.tree.implementations"), implementationsPanel);
                 tabs.addTab(I18n.translate("info_panel.tree.calls"), callPanel);
@@ -482,11 +489,14 @@ public class Gui implements LanguageChangeListener {
                                 }
                         });
 
+                        showStructure(ed);
+
                         return ed;
                 });
                 if (editorPanel != null) {
                         openFiles.setSelectedComponent(editors.get(entry).getUi());
                 }
+
                 return editorPanel;
         }
 
@@ -506,6 +516,7 @@ public class Gui implements LanguageChangeListener {
         public void closeEditor(EditorPanel ed) {
                 openFiles.remove(ed.getUi());
                 editors.inverse().remove(ed);
+                showStructure(getActiveEditor());
                 ed.destroy();
         }
 
@@ -595,6 +606,32 @@ public class Gui implements LanguageChangeListener {
                 infoPanel.startRenaming();
         }
 
+        public void showStructure(EditorPanel editor) {
+                JTree structureTree = this.structurePanel.getStructureTree();
+                structureTree.setModel(null);
+
+                if (editor == null) {
+                        this.structurePanel.getSortingPanel().setVisible(false);
+                        return;
+                }
+
+                ClassEntry classEntry = editor.getClassHandle().getRef();
+                if (classEntry == null) return;
+
+                this.structurePanel.getSortingPanel().setVisible(true);
+
+                // get the class structure
+                StructureTreeNode node = this.controller.getClassStructure(classEntry, this.structurePanel.shouldHideDeobfuscated());
+
+                // show the tree at the root
+                TreePath path = getPathToRoot(node);
+                structureTree.setModel(new DefaultTreeModel((TreeNode) path.getPathComponent(0)));
+                structureTree.expandPath(path);
+                structureTree.setSelectionRow(structureTree.getRowForPath(path));
+
+                redraw();
+        }
+
         public void showInheritance(EditorPanel editor) {
                 EntryReference<Entry<?>, Entry<?>> cursorReference = editor.getCursorReference();
                 if (cursorReference == null) return;
@@ -621,7 +658,7 @@ public class Gui implements LanguageChangeListener {
                         inheritanceTree.setSelectionRow(inheritanceTree.getRowForPath(path));
                 }
 
-                tabs.setSelectedIndex(0);
+                tabs.setSelectedIndex(1);
 
                 redraw();
         }
@@ -649,7 +686,7 @@ public class Gui implements LanguageChangeListener {
                         implementationsTree.setSelectionRow(implementationsTree.getRowForPath(path));
                 }
 
-                tabs.setSelectedIndex(1);
+                tabs.setSelectedIndex(2);
 
                 redraw();
         }
@@ -669,7 +706,7 @@ public class Gui implements LanguageChangeListener {
                         callsTree.setModel(new DefaultTreeModel(node));
                 }
 
-                tabs.setSelectedIndex(2);
+                tabs.setSelectedIndex(3);
 
                 redraw();
         }
@@ -893,9 +930,10 @@ public class Gui implements LanguageChangeListener {
         public void retranslateUi() {
                 this.jarFileChooser.setTitle(I18n.translate("menu.file.jar.open"));
                 this.exportJarFileChooser.setTitle(I18n.translate("menu.file.export.jar"));
-                this.tabs.setTitleAt(0, I18n.translate("info_panel.tree.inheritance"));
-                this.tabs.setTitleAt(1, I18n.translate("info_panel.tree.implementations"));
-                this.tabs.setTitleAt(2, I18n.translate("info_panel.tree.calls"));
+                this.tabs.setTitleAt(0, I18n.translate("info_panel.tree.structure"));
+                this.tabs.setTitleAt(1, I18n.translate("info_panel.tree.inheritance"));
+                this.tabs.setTitleAt(2, I18n.translate("info_panel.tree.implementations"));
+                this.tabs.setTitleAt(3, I18n.translate("info_panel.tree.calls"));
                 this.logTabs.setTitleAt(0, I18n.translate("log_panel.users"));
                 this.logTabs.setTitleAt(1, I18n.translate("log_panel.messages"));
                 this.connectionStatusLabel.setText(I18n.translate(connectionState == ConnectionState.NOT_CONNECTED ? "status.disconnected" : "status.connected"));
@@ -907,6 +945,7 @@ public class Gui implements LanguageChangeListener {
                 this.deobfPanel.retranslateUi();
                 this.deobfPanelPopupMenu.retranslateUi();
                 this.infoPanel.retranslateUi();
+                this.structurePanel.retranslateUi();
                 this.editors.values().forEach(EditorPanel::retranslateUi);
         }
 
diff --git a/enigma-swing/src/main/java/cuchaz/enigma/gui/GuiController.java b/enigma-swing/src/main/java/cuchaz/enigma/gui/GuiController.java
index 4f7819e4..5217b25c 100644
--- a/enigma-swing/src/main/java/cuchaz/enigma/gui/GuiController.java
+++ b/enigma-swing/src/main/java/cuchaz/enigma/gui/GuiController.java
@@ -57,10 +57,7 @@ import cuchaz.enigma.translation.mapping.serde.MappingParseException;
 import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters;
 import cuchaz.enigma.translation.mapping.tree.EntryTree;
 import cuchaz.enigma.translation.mapping.tree.HashEntryTree;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-import cuchaz.enigma.translation.representation.entry.Entry;
-import cuchaz.enigma.translation.representation.entry.FieldEntry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
+import cuchaz.enigma.translation.representation.entry.*;
 import cuchaz.enigma.utils.I18n;
 import cuchaz.enigma.utils.Utils;
 import cuchaz.enigma.utils.validation.ValidationContext;
@@ -395,6 +392,12 @@ public class GuiController implements ClientPacketHandler {
                 chp.invalidateMapped();
         }
 
+        public StructureTreeNode getClassStructure(ClassEntry entry, boolean hideDeobfuscated) {
+                StructureTreeNode rootNode = new StructureTreeNode(this.project, entry, entry);
+                rootNode.load(this.project, hideDeobfuscated);
+                return rootNode;
+        }
+
         public ClassInheritanceTreeNode getClassInheritance(ClassEntry entry) {
                 Translator translator = project.getMapper().getDeobfuscator();
                 ClassInheritanceTreeNode rootNode = indexTreeBuilder.buildClassInheritance(translator, entry);
@@ -454,6 +457,7 @@ public class GuiController implements ClientPacketHandler {
                 Entry<?> entry = reference.getNameableEntry();
                 EntryMapping previous = project.getMapper().getDeobfMapping(entry);
                 project.getMapper().mapFromObf(vc, entry, previous != null ? previous.withName(newName) : new EntryMapping(newName), true, validateOnly);
+                gui.showStructure(gui.getActiveEditor());
 
                 if (validateOnly || !vc.canProceed()) return;
 
@@ -466,6 +470,7 @@ public class GuiController implements ClientPacketHandler {
         @Override
         public void removeMapping(ValidationContext vc, EntryReference<Entry<?>, Entry<?>> reference) {
                 project.getMapper().removeByObf(vc, reference.getNameableEntry());
+                gui.showStructure(gui.getActiveEditor());
 
                 if (!vc.canProceed()) return;
 
@@ -504,6 +509,7 @@ public class GuiController implements ClientPacketHandler {
                 EntryRemapper mapper = project.getMapper();
                 Entry<?> entry = reference.getNameableEntry();
                 mapper.mapFromObf(vc, entry, new EntryMapping(mapper.deobfuscate(entry).getName()));
+                gui.showStructure(gui.getActiveEditor());
 
                 if (!vc.canProceed()) return;
 
diff --git a/enigma-swing/src/main/java/cuchaz/enigma/gui/panels/StructurePanel.java b/enigma-swing/src/main/java/cuchaz/enigma/gui/panels/StructurePanel.java
new file mode 100644
index 00000000..139923c5
--- /dev/null
+++ b/enigma-swing/src/main/java/cuchaz/enigma/gui/panels/StructurePanel.java
@@ -0,0 +1,98 @@
+package cuchaz.enigma.gui.panels;
+
+import cuchaz.enigma.analysis.StructureTreeNode;
+import cuchaz.enigma.gui.Gui;
+import cuchaz.enigma.gui.util.GuiUtil;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.FieldEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+import cuchaz.enigma.translation.representation.entry.ParentedEntry;
+import cuchaz.enigma.utils.I18n;
+
+import javax.swing.*;
+import javax.swing.tree.DefaultTreeCellRenderer;
+import javax.swing.tree.TreePath;
+import java.awt.*;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+public class StructurePanel extends JPanel {
+    private JPanel sortingPanel;
+    private JCheckBox hideDeobfuscated;
+
+    private JTree structureTree;
+
+    public StructurePanel(Gui gui) {
+        this.sortingPanel = new JPanel();
+        this.hideDeobfuscated = new JCheckBox(I18n.translate("info_panel.tree.structure.hide_deobfuscated"));
+        this.hideDeobfuscated.addActionListener(event -> gui.showStructure(gui.getActiveEditor()));
+        this.sortingPanel.add(this.hideDeobfuscated);
+        this.sortingPanel.setVisible(false);
+
+        this.structureTree = new JTree();
+        this.structureTree.setModel(null);
+        this.structureTree.setCellRenderer(new StructureTreeCellRenderer());
+        this.structureTree.setShowsRootHandles(true);
+        this.structureTree.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent event) {
+                if (event.getClickCount() >= 2 && event.getButton() == MouseEvent.BUTTON1) {
+                    // get the selected node
+                    TreePath path = structureTree.getSelectionPath();
+                    if (path == null) {
+                        return;
+                    }
+
+                    Object node = path.getLastPathComponent();
+                    if (node instanceof StructureTreeNode) {
+                        gui.getController().navigateTo(((StructureTreeNode) node).getEntry());
+                    }
+                }
+            }
+        });
+
+        this.setLayout(new BorderLayout());
+        this.add(this.sortingPanel, BorderLayout.NORTH);
+        this.add(new JScrollPane(this.structureTree));
+    }
+
+    public JPanel getSortingPanel() {
+        return this.sortingPanel;
+    }
+
+    /**
+     * Returns whether the "Hide Deobfuscated" option of this structure panel is selected.
+     */
+    public boolean shouldHideDeobfuscated() {
+        return this.hideDeobfuscated.isSelected();
+    }
+
+    public JTree getStructureTree() {
+        return this.structureTree;
+    }
+
+    public void retranslateUi() {
+        this.hideDeobfuscated.setText(I18n.translate("info_panel.tree.structure.hide_deobfuscated"));
+    }
+
+    class StructureTreeCellRenderer extends DefaultTreeCellRenderer {
+
+        @Override
+        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
+            JComponent c = (JComponent) super.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);
+            ParentedEntry entry = ((StructureTreeNode) value).getEntry();
+
+            if (entry instanceof ClassEntry) {
+                this.setIcon(GuiUtil.CLASS_ICON);
+            } else if (entry instanceof MethodEntry) {
+                this.setIcon(((MethodEntry) entry).isConstructor() ? GuiUtil.CONSTRUCTOR_ICON : GuiUtil.METHOD_ICON);
+            } else if (entry instanceof FieldEntry) {
+                this.setIcon(GuiUtil.FIELD_ICON);
+            }
+
+            this.setText(value.toString());
+
+            return c;
+        }
+    }
+}
diff --git a/enigma-swing/src/main/java/cuchaz/enigma/gui/stats/StatsGenerator.java b/enigma-swing/src/main/java/cuchaz/enigma/gui/stats/StatsGenerator.java
index b898eac3..20d6a0eb 100644
--- a/enigma-swing/src/main/java/cuchaz/enigma/gui/stats/StatsGenerator.java
+++ b/enigma-swing/src/main/java/cuchaz/enigma/gui/stats/StatsGenerator.java
@@ -3,8 +3,6 @@ package cuchaz.enigma.gui.stats;
 import cuchaz.enigma.EnigmaProject;
 import cuchaz.enigma.ProgressListener;
 import cuchaz.enigma.analysis.index.EntryIndex;
-import cuchaz.enigma.api.service.NameProposalService;
-import cuchaz.enigma.api.service.ObfuscationTestService;
 import cuchaz.enigma.translation.mapping.EntryRemapper;
 import cuchaz.enigma.translation.mapping.EntryResolver;
 import cuchaz.enigma.translation.mapping.ResolutionStrategy;
@@ -15,18 +13,16 @@ import cuchaz.enigma.utils.I18n;
 import java.util.*;
 
 public class StatsGenerator {
+    private final EnigmaProject project;
     private final EntryIndex entryIndex;
     private final EntryRemapper mapper;
     private final EntryResolver entryResolver;
-    private final List<ObfuscationTestService> obfuscationTestServices;
-    private final List<NameProposalService> nameProposalServices;
 
     public StatsGenerator(EnigmaProject project) {
-        entryIndex = project.getJarIndex().getEntryIndex();
-        mapper = project.getMapper();
-        entryResolver = project.getJarIndex().getEntryResolver();
-        obfuscationTestServices = project.getEnigma().getServices().get(ObfuscationTestService.TYPE);
-        nameProposalServices = project.getEnigma().getServices().get(NameProposalService.TYPE);
+        this.project = project;
+        this.entryIndex = project.getJarIndex().getEntryIndex();
+        this.mapper = project.getMapper();
+        this.entryResolver = project.getJarIndex().getEntryResolver();
     }
 
     public StatsResult generate(ProgressListener progress, Set<StatsMember> includedMembers, String topLevelPackage, boolean includeSynthetic) {
@@ -111,36 +107,9 @@ public class StatsGenerator {
     }
 
     private void update(Map<String, Integer> counts, Entry<?> entry) {
-        if (isObfuscated(entry)) {
+        if (project.isObfuscated(entry)) {
             String parent = mapper.deobfuscate(entry.getAncestry().get(0)).getName().replace('/', '.');
             counts.put(parent, counts.getOrDefault(parent, 0) + 1);
         }
     }
-
-    private boolean isObfuscated(Entry<?> entry) {
-        String name = entry.getName();
-
-        if (!obfuscationTestServices.isEmpty()) {
-            for (ObfuscationTestService service : obfuscationTestServices) {
-                if (service.testDeobfuscated(entry)) {
-                    return false;
-                }
-            }
-        }
-
-        if (!nameProposalServices.isEmpty()) {
-            for (NameProposalService service : nameProposalServices) {
-                if (service.proposeName(entry, mapper).isPresent()) {
-                    return false;
-                }
-            }
-        }
-
-        String mappedName = mapper.deobfuscate(entry).getName();
-        if (mappedName != null && !mappedName.isEmpty() && !mappedName.equals(name)) {
-            return false;
-        }
-
-        return true;
-    }
 }
diff --git a/enigma-swing/src/main/java/cuchaz/enigma/gui/util/GuiUtil.java b/enigma-swing/src/main/java/cuchaz/enigma/gui/util/GuiUtil.java
index 7fe942d0..6393913d 100644
--- a/enigma-swing/src/main/java/cuchaz/enigma/gui/util/GuiUtil.java
+++ b/enigma-swing/src/main/java/cuchaz/enigma/gui/util/GuiUtil.java
@@ -1,24 +1,25 @@
 package cuchaz.enigma.gui.util;
 
-import java.awt.Color;
-import java.awt.Cursor;
-import java.awt.Desktop;
-import java.awt.Font;
+import cuchaz.enigma.utils.Os;
+
+import javax.imageio.ImageIO;
+import javax.swing.*;
+import java.awt.*;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 import java.awt.font.TextAttribute;
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.Map;
 
-import javax.swing.JComponent;
-import javax.swing.JLabel;
-import javax.swing.ToolTipManager;
-
-import cuchaz.enigma.utils.Os;
-
 public class GuiUtil {
+    public static final Icon CLASS_ICON = loadIcon("class");
+    public static final Icon METHOD_ICON = loadIcon("method");
+    public static final Icon FIELD_ICON = loadIcon("field");
+    public static final Icon CONSTRUCTOR_ICON = loadIcon("constructor");
+
     public static void openUrl(String url) {
         try {
             switch (Os.getOs()) {
@@ -70,4 +71,15 @@ public class GuiUtil {
         return link;
     }
 
+    public static Icon loadIcon(String name) {
+        try {
+            InputStream inputStream = GuiUtil.class.getResourceAsStream("/icons/" + name + ".png");
+            Image image = ImageIO.read(inputStream).getScaledInstance(ScaleUtil.scale(16), ScaleUtil.scale(16), Image.SCALE_DEFAULT);
+            return new ImageIcon(image);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
 }
diff --git a/enigma-swing/src/main/resources/icons/class.png b/enigma-swing/src/main/resources/icons/class.png
new file mode 100644
index 00000000..17d82ecd
--- /dev/null
+++ b/enigma-swing/src/main/resources/icons/class.png
diff --git a/enigma-swing/src/main/resources/icons/constructor.png b/enigma-swing/src/main/resources/icons/constructor.png
new file mode 100644
index 00000000..3728b554
--- /dev/null
+++ b/enigma-swing/src/main/resources/icons/constructor.png
diff --git a/enigma-swing/src/main/resources/icons/field.png b/enigma-swing/src/main/resources/icons/field.png
new file mode 100644
index 00000000..4ac1aab9
--- /dev/null
+++ b/enigma-swing/src/main/resources/icons/field.png
diff --git a/enigma-swing/src/main/resources/icons/method.png b/enigma-swing/src/main/resources/icons/method.png
new file mode 100644
index 00000000..e4e96797
--- /dev/null
+++ b/enigma-swing/src/main/resources/icons/method.png
diff --git a/enigma/src/main/java/cuchaz/enigma/EnigmaProject.java b/enigma/src/main/java/cuchaz/enigma/EnigmaProject.java
index fcd2c96a..a01eca19 100644
--- a/enigma/src/main/java/cuchaz/enigma/EnigmaProject.java
+++ b/enigma/src/main/java/cuchaz/enigma/EnigmaProject.java
@@ -18,6 +18,7 @@ import java.util.stream.Stream;
 
 import com.google.common.base.Functions;
 import com.google.common.base.Preconditions;
+import cuchaz.enigma.api.service.ObfuscationTestService;
 import cuchaz.enigma.classprovider.ObfuscationFixClassProvider;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.tree.ClassNode;
@@ -158,6 +159,35 @@ public class EnigmaProject {
                 return obfReference.isNamed() && isRenamable(obfReference.getNameableEntry());
         }
 
+        public boolean isObfuscated(Entry<?> entry) {
+                String name = entry.getName();
+
+                List<ObfuscationTestService> obfuscationTestServices = this.getEnigma().getServices().get(ObfuscationTestService.TYPE);
+                if (!obfuscationTestServices.isEmpty()) {
+                        for (ObfuscationTestService service : obfuscationTestServices) {
+                                if (service.testDeobfuscated(entry)) {
+                                        return false;
+                                }
+                        }
+                }
+
+                List<NameProposalService> nameProposalServices = this.getEnigma().getServices().get(NameProposalService.TYPE);
+                if (!nameProposalServices.isEmpty()) {
+                        for (NameProposalService service : nameProposalServices) {
+                                if (service.proposeName(entry, mapper).isPresent()) {
+                                        return false;
+                                }
+                        }
+                }
+
+                String mappedName = mapper.deobfuscate(entry).getName();
+                if (mappedName != null && !mappedName.isEmpty() && !mappedName.equals(name)) {
+                        return false;
+                }
+
+                return true;
+        }
+
         public JarExport exportRemappedJar(ProgressListener progress) {
                 Collection<ClassEntry> classEntries = jarIndex.getEntryIndex().getClasses();
                 ClassProvider fixingClassProvider = new ObfuscationFixClassProvider(classProvider, jarIndex);
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/StructureTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/StructureTreeNode.java
new file mode 100644
index 00000000..f310aa75
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/StructureTreeNode.java
@@ -0,0 +1,123 @@
+package cuchaz.enigma.analysis;
+
+import cuchaz.enigma.EnigmaProject;
+import cuchaz.enigma.api.service.NameProposalService;
+import cuchaz.enigma.translation.TranslateResult;
+import cuchaz.enigma.translation.mapping.EntryRemapper;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.*;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import java.util.List;
+
+public class StructureTreeNode extends DefaultMutableTreeNode {
+    private final List<NameProposalService> nameProposalServices;
+    private final EntryRemapper mapper;
+    private final ClassEntry parentEntry;
+    private final ParentedEntry entry;
+
+    public StructureTreeNode(EnigmaProject project, ClassEntry parentEntry, ParentedEntry entry) {
+        this.nameProposalServices = project.getEnigma().getServices().get(NameProposalService.TYPE);
+        this.mapper = project.getMapper();
+        this.parentEntry = parentEntry;
+        this.entry = entry;
+    }
+
+    /**
+     * Returns the parented entry corresponding to this tree node.
+     */
+    public ParentedEntry getEntry() {
+        return this.entry;
+    }
+
+    public void load(EnigmaProject project, boolean hideDeobfuscated) {
+        List<ParentedEntry> children = project.getJarIndex().getChildrenByClass().get(this.parentEntry);
+
+        for (ParentedEntry child : children) {
+            StructureTreeNode childNode = new StructureTreeNode(project, this.parentEntry, child);
+
+            if (child instanceof ClassEntry) {
+                childNode = new StructureTreeNode(project, (ClassEntry) child, child);
+                childNode.load(project, hideDeobfuscated);
+            }
+
+            // don't add deobfuscated members if hideDeobfuscated is true, unless it's an inner class
+            if (hideDeobfuscated && !project.isObfuscated(child) && !(child instanceof ClassEntry)) {
+                continue;
+            }
+
+            // don't add constructor methods if hideDeobfuscated is true
+            if (hideDeobfuscated && (child instanceof MethodEntry) && ((MethodEntry) child).isConstructor()) {
+                continue;
+            }
+
+            this.add(childNode);
+        }
+    }
+
+    @Override
+    public String toString() {
+        TranslateResult<ParentedEntry> translateResult = this.mapper.extendedDeobfuscate(this.entry);
+        String result = translateResult.getValue().getName();
+
+        if (translateResult.isObfuscated()) {
+            if (!this.nameProposalServices.isEmpty()) {
+                for (NameProposalService service : this.nameProposalServices) {
+                    if (service.proposeName(this.entry, this.mapper).isPresent()) {
+                        result = service.proposeName(this.entry, this.mapper).get();
+                    }
+                }
+            }
+        }
+
+        if (this.entry instanceof FieldDefEntry) {
+            FieldDefEntry field = (FieldDefEntry) translateResult.getValue();
+            String returnType = this.parseDesc(field.getDesc());
+
+            result = result + ": " + returnType;
+        } else if (this.entry instanceof MethodDefEntry) {
+            MethodDefEntry method = (MethodDefEntry) translateResult.getValue();
+            String args = this.parseArgs(method.getDesc().getArgumentDescs());
+            String returnType = this.parseDesc(method.getDesc().getReturnDesc());
+
+            if (method.isConstructor()) {
+                result = method.getParent().getSimpleName() + args;
+            } else {
+                result = result + args + ": " + returnType;
+            }
+        }
+
+        return result;
+    }
+
+    private String parseArgs(List<TypeDescriptor> args) {
+        if (args.size() > 0) {
+            String result = "(";
+
+            for (int i = 0; i < args.size(); i++) {
+                if (i > 0) {
+                    result += ", ";
+                }
+
+                result += this.parseDesc(args.get(i));
+            }
+
+            return result + ")";
+        }
+
+        return "()";
+    }
+
+    private String parseDesc(TypeDescriptor desc) {
+        if (desc.isVoid()) return "void";
+        if (desc.isPrimitive()) return desc.getPrimitive().getKeyword();
+        if (desc.isType()) return desc.getTypeEntry().getSimpleName();
+
+        if (desc.isArray()) {
+            if (desc.getArrayType().isPrimitive()) return desc.getArrayType().getPrimitive().getKeyword() + "[]";
+            if (desc.getArrayType().isType()) return desc.getArrayType().getTypeEntry().getSimpleName() + "[]";
+        }
+
+        return null;
+    }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/index/JarIndex.java b/enigma/src/main/java/cuchaz/enigma/analysis/index/JarIndex.java
index b5ad91a8..aa360cfd 100644
--- a/enigma/src/main/java/cuchaz/enigma/analysis/index/JarIndex.java
+++ b/enigma/src/main/java/cuchaz/enigma/analysis/index/JarIndex.java
@@ -11,8 +11,7 @@
 
 package cuchaz.enigma.analysis.index;
 
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
+import com.google.common.collect.*;
 import cuchaz.enigma.Enigma;
 import cuchaz.enigma.ProgressListener;
 import cuchaz.enigma.analysis.ReferenceTargetType;
@@ -23,10 +22,7 @@ import cuchaz.enigma.translation.representation.Lambda;
 import cuchaz.enigma.translation.representation.entry.*;
 import cuchaz.enigma.utils.I18n;
 
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.*;
 
 public class JarIndex implements JarIndexer {
         private final Set<String> indexedClasses = new HashSet<>();
@@ -40,6 +36,7 @@ public class JarIndex implements JarIndexer {
         private final Collection<JarIndexer> indexers;
 
         private final Multimap<String, MethodDefEntry> methodImplementations = HashMultimap.create();
+        private final ListMultimap<ClassEntry, ParentedEntry> childrenByClass;
 
         public JarIndex(EntryIndex entryIndex, InheritanceIndex inheritanceIndex, ReferenceIndex referenceIndex, BridgeMethodIndex bridgeMethodIndex, PackageVisibilityIndex packageVisibilityIndex) {
                 this.entryIndex = entryIndex;
@@ -49,6 +46,7 @@ public class JarIndex implements JarIndexer {
                 this.packageVisibilityIndex = packageVisibilityIndex;
                 this.indexers = Arrays.asList(entryIndex, inheritanceIndex, referenceIndex, bridgeMethodIndex, packageVisibilityIndex);
                 this.entryResolver = new IndexEntryResolver(this);
+                this.childrenByClass = ArrayListMultimap.create();
         }
 
         public static JarIndex empty() {
@@ -101,6 +99,9 @@ public class JarIndex implements JarIndexer {
                 }
 
                 indexers.forEach(indexer -> indexer.indexClass(classEntry));
+                if (classEntry.isInnerClass() && !classEntry.getAccess().isSynthetic()) {
+                        childrenByClass.put(classEntry.getParent(), classEntry);
+                }
         }
 
         @Override
@@ -110,6 +111,9 @@ public class JarIndex implements JarIndexer {
                 }
 
                 indexers.forEach(indexer -> indexer.indexField(fieldEntry));
+                if (!fieldEntry.getAccess().isSynthetic()) {
+                        childrenByClass.put(fieldEntry.getParent(), fieldEntry);
+                }
         }
 
         @Override
@@ -119,6 +123,9 @@ public class JarIndex implements JarIndexer {
                 }
 
                 indexers.forEach(indexer -> indexer.indexMethod(methodEntry));
+                if (!methodEntry.getAccess().isSynthetic() && !methodEntry.getName().equals("<clinit>")) {
+                        childrenByClass.put(methodEntry.getParent(), methodEntry);
+                }
 
                 if (!methodEntry.isConstructor()) {
                         methodImplementations.put(methodEntry.getParent().getFullName(), methodEntry);
@@ -176,6 +183,10 @@ public class JarIndex implements JarIndexer {
                 return entryResolver;
         }
 
+        public ListMultimap<ClassEntry, ParentedEntry> getChildrenByClass() {
+                return this.childrenByClass;
+        }
+
         public boolean isIndexed(String internalName) {
                 return indexedClasses.contains(internalName);
         }
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/TypeDescriptor.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/TypeDescriptor.java
index a7dccfcf..6a1b82f0 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/representation/TypeDescriptor.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/TypeDescriptor.java
@@ -235,14 +235,14 @@ public class TypeDescriptor implements Translatable {
         }
 
         public enum Primitive {
-                BYTE('B'),
-                CHARACTER('C'),
-                SHORT('S'),
-                INTEGER('I'),
-                LONG('J'),
-                FLOAT('F'),
-                DOUBLE('D'),
-                BOOLEAN('Z');
+                BYTE('B', "byte"),
+                CHARACTER('C', "char"),
+                SHORT('S', "short"),
+                INTEGER('I', "int"),
+                LONG('J', "long"),
+                FLOAT('F', "float"),
+                DOUBLE('D', "double"),
+                BOOLEAN('Z', "boolean");
 
                 private static final Map<Character, Primitive> lookup;
 
@@ -254,9 +254,11 @@ public class TypeDescriptor implements Translatable {
                 }
 
                 private char code;
+                private String keyword;
 
-                Primitive(char code) {
+                Primitive(char code, String keyword) {
                         this.code = code;
+                        this.keyword = keyword;
                 }
 
                 public static Primitive get(char code) {
@@ -266,5 +268,12 @@ public class TypeDescriptor implements Translatable {
                 public char getCode() {
                         return this.code;
                 }
+
+                /**
+                 * Returns the Java keyword corresponding to this primitive.
+                 */
+                public String getKeyword() {
+                        return this.keyword;
+                }
         }
 }
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ClassEntry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ClassEntry.java
index 4a50021c..b4a22f1e 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ClassEntry.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/ClassEntry.java
@@ -134,6 +134,9 @@ public class ClassEntry extends ParentedEntry<ClassEntry> implements Comparable<
                 return name;
         }
 
+        /**
+         * Returns whether this class entry has a parent, and therefore is an inner class.
+         */
         public boolean isInnerClass() {
                 return parent != null;
         }
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/Entry.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/Entry.java
index ff392fee..6fd412a0 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/Entry.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/entry/Entry.java
@@ -29,6 +29,13 @@ public interface Entry<P extends Entry<?>> extends Translatable {
                 return getName();
         }
 
+        /**
+         * Returns the parent entry of this entry.
+         *
+         * <p>The parent entry should be a {@linkplain MethodEntry method} for local variables,
+         * a {@linkplain ClassEntry class} for methods, fields and inner classes, and {@code null}
+         * for other classes.</p>
+         */
         @Nullable
         P getParent();
 
diff --git a/enigma/src/main/resources/lang/en_us.json b/enigma/src/main/resources/lang/en_us.json
index 9db4e1fc..8195bb1f 100644
--- a/enigma/src/main/resources/lang/en_us.json
+++ b/enigma/src/main/resources/lang/en_us.json
@@ -101,6 +101,8 @@
         "info_panel.identifier.index": "Index",
         "info_panel.editor.class.decompiling": "(decompiling...)",
         "info_panel.editor.class.not_found": "Unable to find class:",
+        "info_panel.tree.structure": "Structure",
+        "info_panel.tree.structure.hide_deobfuscated": "Hide deobfuscated members",
         "info_panel.tree.inheritance": "Inheritance",
         "info_panel.tree.implementations": "Implementations",
         "info_panel.tree.calls": "Call Graph",
diff --git a/enigma/src/main/resources/lang/fr_fr.json b/enigma/src/main/resources/lang/fr_fr.json
index 127b9c88..43bea4de 100644
--- a/enigma/src/main/resources/lang/fr_fr.json
+++ b/enigma/src/main/resources/lang/fr_fr.json
@@ -101,6 +101,8 @@
         "info_panel.identifier.index": "Index",
         "info_panel.editor.class.decompiling": "(décompilation...)",
         "info_panel.editor.class.not_found": "Impossible de trouver la classe :",
+        "info_panel.tree.structure": "Structure",
+        "info_panel.tree.structure.hide_deobfuscated": "Masquer les membres déobfusqués",
         "info_panel.tree.inheritance": "Héritage",
         "info_panel.tree.implementations": "Implémentations",
         "info_panel.tree.calls": "Graphique des appels",