From 6e86f8eb5e45a1cab51a7ce5be16a2c5097a6067 Mon Sep 17 00:00:00 2001 From: mudkip Date: Sat, 24 Jun 2023 01:13:34 -0600 Subject: Fix double clicking an entry in the "implementations" window not navigating to the respective class/method (#516) * fix double clicking an entry in the implementations window not navigating to the class/method * fix styling--- .../gui/elements/AbstractInheritanceTree.java | 17 ++++++++----- .../analysis/ClassImplementationsTreeNode.java | 20 ++++------------ .../enigma/analysis/ClassInheritanceTreeNode.java | 23 ++++-------------- .../java/cuchaz/enigma/analysis/ClassTreeNode.java | 28 ++++++++++++++++++++++ .../analysis/MethodImplementationsTreeNode.java | 22 +++++------------ .../enigma/analysis/MethodInheritanceTreeNode.java | 26 +++++++------------- .../cuchaz/enigma/analysis/MethodTreeNode.java | 23 ++++++++++++++++++ 7 files changed, 86 insertions(+), 73 deletions(-) create mode 100644 enigma/src/main/java/cuchaz/enigma/analysis/ClassTreeNode.java create mode 100644 enigma/src/main/java/cuchaz/enigma/analysis/MethodTreeNode.java diff --git a/enigma-swing/src/main/java/cuchaz/enigma/gui/elements/AbstractInheritanceTree.java b/enigma-swing/src/main/java/cuchaz/enigma/gui/elements/AbstractInheritanceTree.java index 3f1625d..8acfcfe 100644 --- a/enigma-swing/src/main/java/cuchaz/enigma/gui/elements/AbstractInheritanceTree.java +++ b/enigma-swing/src/main/java/cuchaz/enigma/gui/elements/AbstractInheritanceTree.java @@ -13,8 +13,9 @@ import javax.swing.tree.TreeCellRenderer; import javax.swing.tree.TreeNode; import javax.swing.tree.TreePath; -import cuchaz.enigma.analysis.ClassInheritanceTreeNode; +import cuchaz.enigma.analysis.ClassTreeNode; import cuchaz.enigma.analysis.MethodInheritanceTreeNode; +import cuchaz.enigma.analysis.MethodTreeNode; import cuchaz.enigma.gui.Gui; import cuchaz.enigma.gui.util.GuiUtil; import cuchaz.enigma.gui.util.SingleTreeSelectionModel; @@ -51,12 +52,16 @@ public abstract class AbstractInheritanceTree { Object node = path.getLastPathComponent(); - if (node instanceof ClassInheritanceTreeNode classNode) { - gui.getController().navigateTo(new ClassEntry(classNode.getObfClassName())); - } else if (node instanceof MethodInheritanceTreeNode methodNode) { - if (methodNode.isImplemented()) { - gui.getController().navigateTo(methodNode.getMethodEntry()); + if (node instanceof ClassTreeNode classNode) { + gui.getController().navigateTo(new ClassEntry(classNode.getClassEntry().getFullName())); + } else if (node instanceof MethodTreeNode methodNode) { + if (methodNode instanceof MethodInheritanceTreeNode inheritanceMethodNode) { + if (!inheritanceMethodNode.isImplemented()) { + return; + } } + + gui.getController().navigateTo(methodNode.getMethodEntry()); } } } diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java index 8ef28d9..306451a 100644 --- a/enigma/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java +++ b/enigma/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java @@ -14,8 +14,6 @@ package cuchaz.enigma.analysis; import java.util.Collection; import java.util.List; -import javax.swing.tree.DefaultMutableTreeNode; - import com.google.common.collect.Lists; import cuchaz.enigma.analysis.index.InheritanceIndex; @@ -24,18 +22,14 @@ import cuchaz.enigma.translation.Translator; import cuchaz.enigma.translation.representation.entry.ClassEntry; import cuchaz.enigma.translation.representation.entry.MethodEntry; -public class ClassImplementationsTreeNode extends DefaultMutableTreeNode { - private final Translator translator; - private final ClassEntry entry; - +public class ClassImplementationsTreeNode extends ClassTreeNode { public ClassImplementationsTreeNode(Translator translator, ClassEntry entry) { - this.translator = translator; - this.entry = entry; + super(translator, entry); } public static ClassImplementationsTreeNode findNode(ClassImplementationsTreeNode node, MethodEntry entry) { // is this the node? - if (node.entry.equals(entry.getParent())) { + if (node.getClassEntry().equals(entry.getParent())) { return node; } @@ -51,13 +45,9 @@ public class ClassImplementationsTreeNode extends DefaultMutableTreeNode { return null; } - public ClassEntry getClassEntry() { - return this.entry; - } - @Override public String toString() { - return translator.translate(entry).toString(); + return translator.translate(this.getClassEntry()).toString(); } public void load(JarIndex index) { @@ -65,7 +55,7 @@ public class ClassImplementationsTreeNode extends DefaultMutableTreeNode { List nodes = Lists.newArrayList(); InheritanceIndex inheritanceIndex = index.getInheritanceIndex(); - Collection inheritors = inheritanceIndex.getChildren(entry); + Collection inheritors = inheritanceIndex.getChildren(this.getClassEntry()); for (ClassEntry inheritor : inheritors) { nodes.add(new ClassImplementationsTreeNode(translator, inheritor)); diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java index 24da23c..dfb2af8 100644 --- a/enigma/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java +++ b/enigma/src/main/java/cuchaz/enigma/analysis/ClassInheritanceTreeNode.java @@ -13,21 +13,15 @@ package cuchaz.enigma.analysis; import java.util.List; -import javax.swing.tree.DefaultMutableTreeNode; - import com.google.common.collect.Lists; import cuchaz.enigma.analysis.index.InheritanceIndex; import cuchaz.enigma.translation.Translator; import cuchaz.enigma.translation.representation.entry.ClassEntry; -public class ClassInheritanceTreeNode extends DefaultMutableTreeNode { - private final Translator translator; - private final ClassEntry obfClassEntry; - +public class ClassInheritanceTreeNode extends ClassTreeNode { public ClassInheritanceTreeNode(Translator translator, String obfClassName) { - this.translator = translator; - this.obfClassEntry = new ClassEntry(obfClassName); + super(translator, new ClassEntry(obfClassName)); } public static ClassInheritanceTreeNode findNode(ClassInheritanceTreeNode node, ClassEntry entry) { @@ -48,27 +42,20 @@ public class ClassInheritanceTreeNode extends DefaultMutableTreeNode { return null; } - /** - * Returns the class entry represented by this tree node. - */ - public ClassEntry getClassEntry() { - return this.obfClassEntry; - } - public String getObfClassName() { - return this.obfClassEntry.getFullName(); + return this.getClassEntry().getFullName(); } @Override public String toString() { - return translator.translate(obfClassEntry).getFullName(); + return this.translator.translate(this.getClassEntry()).getFullName(); } public void load(InheritanceIndex ancestries, boolean recurse) { // get all the child nodes List nodes = Lists.newArrayList(); - for (ClassEntry inheritor : ancestries.getChildren(this.obfClassEntry)) { + for (ClassEntry inheritor : ancestries.getChildren(this.getClassEntry())) { nodes.add(new ClassInheritanceTreeNode(translator, inheritor.getFullName())); } diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/ClassTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/ClassTreeNode.java new file mode 100644 index 0000000..90dc458 --- /dev/null +++ b/enigma/src/main/java/cuchaz/enigma/analysis/ClassTreeNode.java @@ -0,0 +1,28 @@ +package cuchaz.enigma.analysis; + +import javax.swing.tree.DefaultMutableTreeNode; + +import cuchaz.enigma.translation.Translator; +import cuchaz.enigma.translation.representation.entry.ClassEntry; + +public abstract class ClassTreeNode extends DefaultMutableTreeNode { + protected final Translator translator; + private final ClassEntry entry; + + public ClassTreeNode(Translator translator, ClassEntry entry) { + this.translator = translator; + this.entry = entry; + } + + /** + * Returns the class entry represented by this tree node. + */ + public ClassEntry getClassEntry() { + return this.entry; + } + + @Override + public String toString() { + return translator.translate(this.entry).getFullName(); + } +} diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java index 83275da..d5a34cd 100644 --- a/enigma/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java +++ b/enigma/src/main/java/cuchaz/enigma/analysis/MethodImplementationsTreeNode.java @@ -14,8 +14,6 @@ package cuchaz.enigma.analysis; import java.util.Collection; import java.util.List; -import javax.swing.tree.DefaultMutableTreeNode; - import com.google.common.collect.Lists; import cuchaz.enigma.analysis.index.EntryIndex; @@ -25,18 +23,13 @@ import cuchaz.enigma.translation.Translator; import cuchaz.enigma.translation.representation.entry.ClassEntry; import cuchaz.enigma.translation.representation.entry.MethodEntry; -public class MethodImplementationsTreeNode extends DefaultMutableTreeNode { - private final Translator translator; - private MethodEntry entry; - +public class MethodImplementationsTreeNode extends MethodTreeNode { public MethodImplementationsTreeNode(Translator translator, MethodEntry entry) { - this.translator = translator; + super(translator, entry); if (entry == null) { throw new IllegalArgumentException("Entry cannot be null!"); } - - this.entry = entry; } public static MethodImplementationsTreeNode findNode(MethodImplementationsTreeNode node, MethodEntry entry) { @@ -57,13 +50,10 @@ public class MethodImplementationsTreeNode extends DefaultMutableTreeNode { return null; } - public MethodEntry getMethodEntry() { - return this.entry; - } - @Override public String toString() { - MethodEntry translatedEntry = translator.translate(entry); + MethodEntry translatedEntry = translator.translate(this.getMethodEntry()); + assert translatedEntry != null; return translatedEntry.getFullName() + "()"; } @@ -73,10 +63,10 @@ public class MethodImplementationsTreeNode extends DefaultMutableTreeNode { EntryIndex entryIndex = index.getEntryIndex(); InheritanceIndex inheritanceIndex = index.getInheritanceIndex(); - Collection descendants = inheritanceIndex.getDescendants(entry.getParent()); + Collection descendants = inheritanceIndex.getDescendants(this.getMethodEntry().getParent()); for (ClassEntry inheritor : descendants) { - MethodEntry methodEntry = entry.withParent(inheritor); + MethodEntry methodEntry = this.getMethodEntry().withParent(inheritor); if (entryIndex.hasMethod(methodEntry)) { nodes.add(new MethodImplementationsTreeNode(translator, methodEntry)); diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java index 2afeed9..5d73e73 100644 --- a/enigma/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java +++ b/enigma/src/main/java/cuchaz/enigma/analysis/MethodInheritanceTreeNode.java @@ -11,8 +11,6 @@ package cuchaz.enigma.analysis; -import javax.swing.tree.DefaultMutableTreeNode; - import cuchaz.enigma.analysis.index.EntryIndex; import cuchaz.enigma.analysis.index.InheritanceIndex; import cuchaz.enigma.analysis.index.JarIndex; @@ -20,14 +18,11 @@ import cuchaz.enigma.translation.Translator; import cuchaz.enigma.translation.representation.entry.ClassEntry; import cuchaz.enigma.translation.representation.entry.MethodEntry; -public class MethodInheritanceTreeNode extends DefaultMutableTreeNode { - private final Translator translator; - private MethodEntry entry; - private boolean implemented; +public class MethodInheritanceTreeNode extends MethodTreeNode { + private final boolean implemented; public MethodInheritanceTreeNode(Translator translator, MethodEntry entry, boolean implemented) { - this.translator = translator; - this.entry = entry; + super(translator, entry); this.implemented = implemented; } @@ -49,22 +44,17 @@ public class MethodInheritanceTreeNode extends DefaultMutableTreeNode { return null; } - /** - * Returns the method entry represented by this tree node. - */ - public MethodEntry getMethodEntry() { - return this.entry; - } - public boolean isImplemented() { return this.implemented; } @Override public String toString() { - MethodEntry translatedEntry = translator.translate(entry); + MethodEntry translatedEntry = translator.translate(this.getMethodEntry()); + assert translatedEntry != null; if (!this.implemented) { + assert translatedEntry.getParent() != null; return translatedEntry.getParent().getFullName(); } else { return translatedEntry.getFullName() + "()"; @@ -81,8 +71,8 @@ public class MethodInheritanceTreeNode extends DefaultMutableTreeNode { boolean ret = false; - for (ClassEntry inheritorEntry : inheritanceIndex.getChildren(this.entry.getParent())) { - MethodEntry methodEntry = new MethodEntry(inheritorEntry, this.entry.getName(), this.entry.getDesc()); + for (ClassEntry inheritorEntry : inheritanceIndex.getChildren(this.getMethodEntry().getParent())) { + MethodEntry methodEntry = new MethodEntry(inheritorEntry, this.getMethodEntry().getName(), this.getMethodEntry().getDesc()); MethodInheritanceTreeNode node = new MethodInheritanceTreeNode(translator, methodEntry, entryIndex.hasMethod(methodEntry)); boolean childOverride = node.load(index); diff --git a/enigma/src/main/java/cuchaz/enigma/analysis/MethodTreeNode.java b/enigma/src/main/java/cuchaz/enigma/analysis/MethodTreeNode.java new file mode 100644 index 0000000..d50a559 --- /dev/null +++ b/enigma/src/main/java/cuchaz/enigma/analysis/MethodTreeNode.java @@ -0,0 +1,23 @@ +package cuchaz.enigma.analysis; + +import javax.swing.tree.DefaultMutableTreeNode; + +import cuchaz.enigma.translation.Translator; +import cuchaz.enigma.translation.representation.entry.MethodEntry; + +public class MethodTreeNode extends DefaultMutableTreeNode { + protected final Translator translator; + private final MethodEntry entry; + + public MethodTreeNode(Translator translator, MethodEntry entry) { + this.translator = translator; + this.entry = entry; + } + + /** + * Returns the method entry represented by this tree node. + */ + public MethodEntry getMethodEntry() { + return this.entry; + } +} -- cgit v1.2.3