jan-leila/Slipstream-Mod-Manager
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Removed redundant group-related tree classes

Browse source
This commit is contained in:
Vhati 2013-11-22 05:54:16 -05:00
parent e25799a78e
commit 78996eaa67
4 changed files with 28 additions and 79 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/main/java/net/vhati/modmanager/ui/tree/ChecklistTreePanel.java
View file

@ -11,13 +11,13 @@ import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.SwingUtilities;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
import net.vhati.modmanager.ui.tree.ChecklistTreeManager;
import net.vhati.modmanager.ui.tree.ChecklistTreeSelectionModel;
import net.vhati.modmanager.ui.tree.GroupTreeCellRenderer;
import net.vhati.modmanager.ui.tree.TreeTransferHandler;
@ -32,9 +32,9 @@ public class ChecklistTreePanel extends JPanel {
super( new BorderLayout() );
DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode( "Root", true );
treeModel = new DefaultTreeModel( rootNode );
treeModel = new DefaultTreeModel( rootNode, true );
tree = new JTree( treeModel );
tree.setCellRenderer( new GroupTreeCellRenderer() );
tree.setCellRenderer( new DefaultTreeCellRenderer() );
tree.setRootVisible( false );
tree.getSelectionModel().setSelectionMode( TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION );
checklistManager = new ChecklistTreeManager( tree, true, null );
@ -103,7 +103,7 @@ public class ChecklistTreePanel extends JPanel {
*/
public void addGroup() {
DefaultMutableTreeNode rootNode = (DefaultMutableTreeNode)treeModel.getRoot();
GroupAwareTreeNode groupNode = new GroupAwareTreeNode( "New Group", true );
DefaultMutableTreeNode groupNode = new DefaultMutableTreeNode( "New Group", true );
rootNode.add( groupNode );
treeModel.nodesWereInserted( rootNode, new int[]{rootNode.getIndex( groupNode )} );
}

23
src/main/java/net/vhati/modmanager/ui/tree/GroupAwareTreeNode.java
View file

@ -1,23 +0,0 @@
package net.vhati.modmanager.ui.tree;
import javax.swing.tree.DefaultMutableTreeNode;
/**
* A TreeNode that remembers whether it allows children when cloned.
*/
public class GroupAwareTreeNode extends DefaultMutableTreeNode {
public GroupAwareTreeNode( Object userObject, boolean allowsChildren ) {
super( userObject, allowsChildren );
}
@Override
public Object clone() {
GroupAwareTreeNode newNode = (GroupAwareTreeNode)super.clone();
newNode.setAllowsChildren( this.getAllowsChildren() );
return newNode;
}
}

39
src/main/java/net/vhati/modmanager/ui/tree/GroupTreeCellRenderer.java
View file

@ -1,39 +0,0 @@
package net.vhati.modmanager.ui.tree;
import java.awt.Component;
import javax.swing.JTree;
import javax.swing.UIManager;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
/**
* A renderer that sets icons based on whether children are allowed.
*
* A group with no children will still have a group icon.
*/
public class GroupTreeCellRenderer extends DefaultTreeCellRenderer {
@Override
public Component getTreeCellRendererComponent( JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus ) {
super.getTreeCellRendererComponent( tree, value, sel, expanded, leaf, row, hasFocus );
if ( value instanceof DefaultMutableTreeNode ) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode)value;
if ( node.getAllowsChildren() ) {
if ( expanded ) {
this.setIcon( this.getDefaultOpenIcon() );
this.setDisabledIcon( this.getDefaultOpenIcon() );
} else {
this.setIcon( this.getDefaultClosedIcon() );
this.setDisabledIcon( this.getDefaultClosedIcon() );
}
} else {
this.setIcon( this.getDefaultLeafIcon() );
this.setDisabledIcon( this.getDefaultLeafIcon() );
}
}
return this;
}
}

37
src/main/java/net/vhati/modmanager/ui/tree/TreeTransferHandler.java
View file

@ -16,6 +16,7 @@ import javax.swing.JTree;
import javax.swing.TransferHandler;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
@ -30,7 +31,9 @@ import javax.swing.tree.TreePath;
* Dragging onto a node that allows children will insert into it.
* Dragging onto a node that doesn't allow children will insert after it.
*
* All nodes must be instances of DefaultMutableTreeNode (or subclasses).
* The TreeModel must be DefaultTreeModel (or a subclass).
* All nodes must be DefaultMutableTreeNode (or a subclass) and properly
* implement Cloneable.
* Set the Jtree's DropMode to ON_OR_INSERT.
* The root node must be hidden, to prevent it from being dragged.
* The tree's selection model may be set to single or multiple.
@ -122,13 +125,13 @@ public class TreeTransferHandler extends TransferHandler {
dstTree.setCursor( Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR) );
if ( dropPath == null ) return false;
DefaultMutableTreeNode dropParentNode = (DefaultMutableTreeNode)dropPath.getLastPathComponent();
MutableTreeNode dropParentNode = (MutableTreeNode)dropPath.getLastPathComponent();
// When dropping onto a non-group node, insert into the position after it instead.
if ( !dropParentNode.getAllowsChildren() ) {
DefaultMutableTreeNode prevParentNode = dropParentNode;
MutableTreeNode prevParentNode = dropParentNode;
dropPath = dropPath.getParentPath();
dropParentNode = (DefaultMutableTreeNode)dropPath.getLastPathComponent();
dropParentNode = (MutableTreeNode)dropPath.getLastPathComponent();
dropIndex = dropParentNode.getIndex( prevParentNode ) + 1;
}
@ -148,7 +151,7 @@ public class TreeTransferHandler extends TransferHandler {
for ( TreePath path : draggedPaths ) {
// Copy the dragged node and any children.
DefaultMutableTreeNode srcNode = (DefaultMutableTreeNode)path.getLastPathComponent();
DefaultMutableTreeNode newNode = (DefaultMutableTreeNode)cloneNodes( srcNode );
MutableTreeNode newNode = (MutableTreeNode)cloneNodes( srcNode );
if ( dropIndex != -1 ) {
// Insert.
@ -158,8 +161,9 @@ public class TreeTransferHandler extends TransferHandler {
}
else {
// Add to the end.
dropParentNode.add( newNode );
dstTreeModel.nodesWereInserted( dropParentNode, new int[]{dropParentNode.getChildCount()-1} );
int addIndex = dropParentNode.getChildCount();
dropParentNode.insert( newNode, addIndex );
dstTreeModel.nodesWereInserted( dropParentNode, new int[]{addIndex} );
if ( !dstTree.isExpanded( dropPath ) ) dstTree.expandPath( dropPath );
}
}
@ -186,12 +190,11 @@ public class TreeTransferHandler extends TransferHandler {
if ( action == TransferHandler.MOVE ) {
// Remove original dragged rows now that the move completed.
// Scan the tree checking equality is fine (DefaultMutableTreeNode's equals() does ==).
try {
TreePath[] draggedPaths = (TreePath[])data.getTransferData( localTreePathFlavor );
for ( TreePath path : draggedPaths ) {
DefaultMutableTreeNode doomedNode = (DefaultMutableTreeNode)path.getLastPathComponent();
MutableTreeNode doomedNode = (MutableTreeNode)path.getLastPathComponent();
TreeNode parentNode = doomedNode.getParent();
int doomedIndex = parentNode.getIndex( doomedNode );
doomedNode.removeFromParent();
@ -208,16 +211,24 @@ public class TreeTransferHandler extends TransferHandler {
/**
* Recursively clones a node and its descendants.
*
* The clone() methods will reuse userObjects, but the nodes themselves will be new.
* The clone() methods will generally do a shallow copy, sharing
* userObjects.
*
* Sidenote: The parameter couldn't just be MutableTreeNode, because that
* doesn't offer the clone() method. And blindly using reflection to
* invoke it wouldn't be pretty. Conceivably, a settable factory could be
* designed to copy specific custom classes (using constructors instead
* of clone(). But that'd be overkill.
*/
@SuppressWarnings("Unchecked")
private DefaultMutableTreeNode cloneNodes( DefaultMutableTreeNode srcNode ) {
DefaultMutableTreeNode resultNode = (DefaultMutableTreeNode)srcNode.clone();
protected MutableTreeNode cloneNodes( DefaultMutableTreeNode srcNode ) {
MutableTreeNode resultNode = (MutableTreeNode)srcNode.clone();
Enumeration enumer = srcNode.children();
while ( enumer.hasMoreElements() ) {
DefaultMutableTreeNode childNode = (DefaultMutableTreeNode)enumer.nextElement();
resultNode.add( cloneNodes( (DefaultMutableTreeNode)childNode ) );
int addIndex = resultNode.getChildCount();
resultNode.insert( cloneNodes( (DefaultMutableTreeNode)childNode ), addIndex );
}
return resultNode;