Jtree Checkboxen

[M@rk]

Hi,

wir haben hier ein kleines Problem. Der Jtree soll uns das Filesystem anzeigen und eine Auswahl mitteles JCheckbox ermöglichen. Wir sind schon so weit, dass die JCheckboxen angezeigt werden. Jedoch verschwindet beim Anklicken der Name des Verzeichnisses bzw. Datei. Außerdem ist keine Mehrfachauswahl möglich.

Hat jemand eine Idee ?

Wir haben die folgenden Klassen angelegt.

FileTree:

package gui;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

/**
 * Tree.
 * 
 * @author javaprakt_01
 */
public class FileTree extends JTree {

    /**
     * ddd.
     */
    private static final long serialVersionUID = 7193372061558999422L;

    /**
     * Tree.
     */
    public FileTree() {
        
        setModel(new FileTreeModel());
        setCellRenderer(new FileTreeRenderer());
        setEditable(true);
        setCellEditor(new CheckBoxEditor());
        
        //setSize(500, 400);
    }
    
    

    /**
     * Tree.
     * 
     * @param args
     *            ddd
     */
    public static void main(String[] args)  {
        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } catch (ClassNotFoundException exc) {
            // TODO Auto-generated catch block
            exc.printStackTrace();
        } catch (InstantiationException exc) {
            // TODO Auto-generated catch block
            exc.printStackTrace();
        } catch (IllegalAccessException exc) {
            // TODO Auto-generated catch block
            exc.printStackTrace();
        } catch (UnsupportedLookAndFeelException exc) {
            // TODO Auto-generated catch block
            exc.printStackTrace();
        }
        JFrame frame = new JFrame("JTree-Test");
        FileTree tree = new FileTree();
        frame.getContentPane().add(new JScrollPane(tree));
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(500, 400);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

}

FileTreeRenderer:

package gui;

import java.awt.Color;
import java.awt.Component;
import java.awt.FlowLayout;
import java.io.File;

import javax.swing.JCheckBox;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTree;
import javax.swing.filechooser.FileSystemView;
import javax.swing.tree.TreeCellRenderer;

/**
 * ddd.
 */
class FileTreeRenderer extends JCheckBox implements TreeCellRenderer {

    /**
     * ddd.
     */
    private static final long serialVersionUID = -8086559279459762134L;

    /**
     * ddd.
     */
    private static FileSystemView system = FileSystemView.getFileSystemView();

    /**
     * ddd.
     */
    private JPanel panel;


    /**
     * ddd.
     */
    private JLabel label;

    /**
     * ddd.
     */
    private JLabel label2;
    
    /**
     * ddd.
     */
    private JCheckBox box = new JCheckBox();;
    /**
     * Tree.
     */
    public FileTreeRenderer() {
        
        
    }

    /**
     * Tree.
     * 
     * @param tree
     *            d
     * @param value
     *            d
     * @param sel
     *            d
     * @param exp
     *            d
     * @param leaf
     *            d
     * @param row
     *            d
     * @param focus
     *            d
     * @return sss d
     */
    // checkstyle: stop parameter number check
    // Benötigt mehr als 5 Parameter
    public Component getTreeCellRendererComponent(JTree tree, Object value,
        boolean sel, boolean exp, boolean leaf, int row, boolean focus) {
 
        File file = (File) value;
        box.setLayout(new FlowLayout());
        //box.setIcon(system.getSystemIcon(file));
        box.setText(system.getSystemDisplayName(file));
        box.setEnabled(tree.isEnabled());
        box.setBackground(Color.WHITE);
 //       box.setSelected(sel);
        
        return box;
    }
    
    /**
     * Returns the value of box.
     * 
     * @return the value of box
     */
    public JCheckBox getBox() {
        return box;
    }

    /**
     * Changes the value of box.
     * 
     * @param box the new value of box 
     */
    public void setBox(JCheckBox box) {
        this.box = box;
    }    
}

FileTreeModel:

package gui;

import java.io.File;

import javax.swing.event.TreeModelListener;
import javax.swing.filechooser.FileSystemView;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;

/**
 * Tree.
 */
class FileTreeModel implements TreeModel {
    
    /**
     * Tree.
     */    
    private static FileSystemView system = FileSystemView.getFileSystemView();
    /**
     * Tree.
     */
    public FileTreeModel() {

    }

    /**
     * Tree.
     * @return sss
     */
    public Object getRoot() {
        return system.getHomeDirectory(); 
    }

    /**
     * Tree.
     * @param parent ggg
     * @return sss
     * 
     */
    public int getChildCount(Object parent) {
        return system.getFiles((File) parent, true).length;
    }

    /**
     * Tree.
     * @param node ddd
     * @return sss
     * 
     */
    public boolean isLeaf(Object node) {
        return ((File) node).isFile();
    }

    /**
     * 
     * Tree.
     * @param li ddd
     * 
     */
    public void addTreeModelListener(TreeModelListener li) {
    }

    /**
     * 
     * Tree.
     * 
     * @param li ddd
     */
    public void removeTreeModelListener(TreeModelListener li) {
    }

    /**
     * 
     * Tree.
     * @param parent ddd
     * @param index ddd
     * @return ddd
     */
    public Object getChild(Object parent, int index) {
        return system.getFiles((File) parent, true)[index];
    }

    /**
     * 
     * Tree.
     * @param parent ddd
     * @param child ddd
     * @return ddd
     */
    public int getIndexOfChild(Object parent, Object child) {
        File[] files = system.getFiles((File) parent, true);
        int tmp = -1;
        for (int i = 0; i < files.length; i++) {
            if (files[i] == child) {
                tmp = i;
            }
        }
        return tmp;
    }

    /**
     * 
     * Tree.
     * @param path dd
     * @param newValue dd
     */
    public void valueForPathChanged(TreePath path, Object newValue) {
    }
}

gruß

 

[Beni]

Ihr benötigt auch noch einen eigenen TreeCellEditor, und ihr müsst den selektiert-Status selbst abspeichern. Das folgende Codestück könnte interessant für euch sein, denn es macht genau dies:

public class FileTree extends JPanel{
    private FileSystemView view = FileSystemView.getFileSystemView();
    
    public FileTree(){
        JTree tree = new JTree();
        tree.setModel( new FileModel() );
        tree.setCellRenderer( new Renderer() );
        tree.setCellEditor( new Editor() );
        tree.setEditable( true ); // <<<<<<<<<<< wichtig
        
        add( new JScrollPane( tree ));
    }
    
    private class Renderer extends JCheckBox implements TreeCellRenderer{
        public Component getTreeCellRendererComponent( JTree tree,
                Object value, boolean selected, boolean expanded, boolean leaf,
                int row, boolean hasFocus ) {
            
            FileNode node = (FileNode)value;
            
            if( selected )
                setBackground( Color.LIGHT_GRAY );
            else
                setBackground( Color.WHITE );
            
            setSelected( node.isSelected() );
            setText( node.getText() );
            // setIcon( node.getIcon() );
            
            return this;
        }
    }

    // <<<<< wichtig
    private class Editor extends Renderer implements TreeCellEditor, ActionListener{
        private List<CellEditorListener> listeners = new ArrayList<CellEditorListener>();
        
        public Editor(){
            addActionListener( this );
        }
        
        public Component getTreeCellEditorComponent( JTree tree, Object value,
                boolean isSelected, boolean expanded, boolean leaf, int row ) {
            return getTreeCellRendererComponent( tree, value, true, expanded, leaf, row, true );
        }
        
        public void actionPerformed( ActionEvent e ) {
            stopCellEditing();
        }

        public void addCellEditorListener( CellEditorListener l ) {
            listeners.add( l );
        }

        public void cancelCellEditing() {
            CellEditorListener[] listeners = 
                this.listeners.toArray( new CellEditorListener[ this.listeners.size() ] );
            ChangeEvent event = new ChangeEvent( this );
            for( CellEditorListener listener : listeners )
                listener.editingCanceled( event );
        }

        public Object getCellEditorValue() {
            return Boolean.valueOf( isSelected() );
        }

        public boolean isCellEditable( EventObject anEvent ) {
            return true;
        }

        public void removeCellEditorListener( CellEditorListener l ) {
            listeners.remove( l );
        }

        public boolean shouldSelectCell( EventObject anEvent ) {
            return true;
        }

        public boolean stopCellEditing() {
            CellEditorListener[] listeners = 
                this.listeners.toArray( new CellEditorListener[ this.listeners.size() ] );
            ChangeEvent event = new ChangeEvent( this );
            for( CellEditorListener listener : listeners )
                listener.editingStopped( event );
            
            return true;
        }
    }
    
    private class FileModel implements TreeModel{
        private FileNode root = new FileNode();
        private List<TreeModelListener> listeners = new ArrayList<TreeModelListener>();
        
        public void addTreeModelListener( TreeModelListener l ) {
            listeners.add( l );
        }

        public Object getChild( Object parent, int index ) {
            return ((FileNode)parent).getChildren()[ index ];
        }

        public int getChildCount( Object parent ) {
            return ((FileNode)parent).getChildren().length;
        }

        public int getIndexOfChild( Object parent, Object child ) {
            FileNode[] children = ((FileNode)parent).getChildren();
            for( int i = 0; i < children.length; i++ )
                if( children[i] == child )
                    return i;
            
            return -1;
        }

        public Object getRoot() {
            return root;
        }

        public boolean isLeaf( Object node ) {
            return ((FileNode)node).isLeaf();
        }

        public void removeTreeModelListener( TreeModelListener l ) {
            listeners.remove( l );
        }

        public void valueForPathChanged( TreePath path, Object newValue ) {
            FileNode node = (FileNode)path.getLastPathComponent();
            node.setSelected( Boolean.TRUE.equals( newValue ) );
            TreeModelEvent event = new TreeModelEvent( this, path );
            for( TreeModelListener listener : listeners )
                listener.treeNodesChanged( event );
        }
    }
    
    private class FileNode{
        private boolean selected; // <<<<<<<<<<<< wichtig
        private File file;
        
        private String text;
        private Icon icon;
        private boolean leaf;
        
        private FileNode[] children;
        
        public FileNode( File file ){
            this.file = file;
            
            text = view.getSystemDisplayName( file );
            icon = view.getSystemIcon( file );
            leaf = !Boolean.TRUE.equals( view.isTraversable( file ) );
        }
        
        public FileNode(){
            File[] roots = view.getRoots();
            children = new FileNode[ roots.length ];
            for( int i = 0; i < children.length; i++ )
                children[i] = new FileNode( roots[i] );
            
            text = "";
            icon = null;
        }
        
        public boolean isLeaf() {
            return leaf;
        }
        
        public void setSelected( boolean selected ) {
            this.selected = selected;
        }
        
        public boolean isSelected() {
            return selected;
        }
        
        public String getText() {
            return text;
        }
        
        public Icon getIcon() {
            return icon;
        }
        
        public FileNode[] getChildren(){
            if( children == null ){
                File[] files = view.getFiles( file, false );
                children = new FileNode[ files == null ? 0 : files.length ];
                for( int i = 0; i < children.length; i++ )
                    children[i] = new FileNode( files[i] );
            }
            return children;
        }
    }
}

 

[M@rk]

Hi,

danke für die schnelle Hilfe! Ist genau das was wir benötigt haben.

gruß