made obfuscated/deobfuscated class selector a bit easier to use

1 files changed, 181 insertions, 0 deletions

diff --git a/src/cuchaz/enigma/gui/ClassSelector.java b/src/cuchaz/enigma/gui/ClassSelector.java
new file mode 100644
index 0000000..338ad80
--- /dev/null
+++ b/src/cuchaz/enigma/gui/ClassSelector.java
@@ -0,0 +1,181 @@
+package cuchaz.enigma.gui;
+
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
+import javax.swing.JTree;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreePath;
+
+import com.beust.jcommander.internal.Lists;
+import com.beust.jcommander.internal.Maps;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Multimap;
+
+import cuchaz.enigma.mapping.ClassEntry;
+
+public class ClassSelector extends JTree
+{
+        private static final long serialVersionUID = -7632046902384775977L;
+        
+        public interface ClassSelectionListener
+        {
+                void onSelectClass( ClassEntry classEntry );
+        }
+        
+        public static Comparator<ClassEntry> ObfuscatedClassEntryComparator;
+        public static Comparator<ClassEntry> DeobfuscatedClassEntryComparator;
+        
+        static
+        {
+                ObfuscatedClassEntryComparator = new Comparator<ClassEntry>( )
+                {
+                        @Override
+                        public int compare( ClassEntry a, ClassEntry b )
+                        {
+                                if( a.getName().length() != b.getName().length() )
+                                {
+                                        return a.getName().length() - b.getName().length();
+                                }
+                                return a.getName().compareTo( b.getName() );
+                        }
+                };
+                
+                DeobfuscatedClassEntryComparator = new Comparator<ClassEntry>( )
+                {
+                        @Override
+                        public int compare( ClassEntry a, ClassEntry b )
+                        {
+                                return a.getName().compareTo( b.getName() );
+                        }
+                };
+        }
+        
+        private ClassSelectionListener m_listener;
+        private Comparator<ClassEntry> m_comparator;
+        
+        public ClassSelector( Comparator<ClassEntry> comparator )
+        {
+                m_comparator = comparator;
+                
+                // configure the tree control
+                setRootVisible( false );
+                setShowsRootHandles( false );
+                setModel( null );
+                
+                // hook events
+                addMouseListener( new MouseAdapter()
+                {
+                        @Override
+                        public void mouseClicked( MouseEvent event )
+                        {
+                                if( m_listener != null && event.getClickCount() == 2 )
+                                {
+                                        // get the selected node
+                                        TreePath path = getSelectionPath();
+                                        if( path != null && path.getLastPathComponent() instanceof ClassSelectorClassNode )
+                                        {
+                                                ClassSelectorClassNode node = (ClassSelectorClassNode)path.getLastPathComponent();
+                                                m_listener.onSelectClass( node.getClassEntry() );
+                                        }
+                                }
+                        }
+                } );
+                
+                // init defaults
+                m_listener = null;
+        }
+        
+        public void setListener( ClassSelectionListener val )
+        {
+                m_listener = val;
+        }
+        
+        public void setClasses( Collection<ClassEntry> classEntries )
+        {
+                if( classEntries == null )
+                {
+                        setModel( null );
+                        return;
+                }
+                
+                // build the package names
+                Map<String,ClassSelectorPackageNode> packages = Maps.newHashMap();
+                for( ClassEntry classEntry : classEntries )
+                {
+                        packages.put( classEntry.getPackageName(), null );
+                }
+                
+                // sort the packages
+                List<String> sortedPackageNames = Lists.newArrayList( packages.keySet() );
+                Collections.sort( sortedPackageNames, new Comparator<String>( )
+                {
+                        @Override
+                        public int compare( String a, String b )
+                        {
+                                // I can never keep this rule straight when writing these damn things...
+                                // a < b => -1, a == b => 0, a > b => +1
+                                
+                                String[] aparts = a.split( "/" );
+                                String[] bparts = b.split( "/" );
+                                for( int i=0; true; i++ )
+                                {
+                                        if( i >= aparts.length )
+                                        {
+                                                return -1;
+                                        }
+                                        else if( i >= bparts.length )
+                                        {
+                                                return 1;
+                                        }
+                                        
+                                        int result = aparts[i].compareTo( bparts[i] );
+                                        if( result != 0 )
+                                        {
+                                                return result;
+                                        }
+                                }
+                        }
+                } );
+                
+                // create the root node and the package nodes
+                DefaultMutableTreeNode root = new DefaultMutableTreeNode();
+                for( String packageName : sortedPackageNames )
+                {
+                        ClassSelectorPackageNode node = new ClassSelectorPackageNode( packageName );
+                        packages.put( packageName, node );
+                        root.add( node );
+                }
+                
+                // put the classes into packages
+                Multimap<String,ClassEntry> packagedClassEntries = ArrayListMultimap.create();
+                for( ClassEntry classEntry : classEntries )
+                {
+                        packagedClassEntries.put( classEntry.getPackageName(), classEntry );
+                }
+                
+                // build the class nodes
+                for( String packageName : packagedClassEntries.keySet() )
+                {
+                        // sort the class entries
+                        List<ClassEntry> classEntriesInPackage = Lists.newArrayList( packagedClassEntries.get( packageName ) );
+                        Collections.sort( classEntriesInPackage, m_comparator );
+                        
+                        // create the nodes in order
+                        for( ClassEntry classEntry : classEntriesInPackage )
+                        {
+                                ClassSelectorPackageNode node = packages.get( packageName );
+                                node.add( new ClassSelectorClassNode( classEntry ) );
+                        }
+                }
+                
+                // finally, update the tree control
+                setModel( new DefaultTreeModel( root ) );
+        }
+}