JRadioButton und JCheckBox im JTree

[SuperFamicom]

Hallo,
ich möchte gerne die Knoten in einem JTree zusammen mit JRadioButton und JCheckBox nach folgendem Schema austatten:

- Parent Node

-- [JRadioButton] [JCheckBox] Child Node 1
-- [JRadioButton] [JCheckBox] Child Node 2
-- …​

Die JRadioButtons gehören pro Parent Node ein und derselber RadioButtonGroup. Beim Überschreiben des TreeCellRenderers lassen sich zwar JCheckBoxes und JRadioButtons darstellen, jedoch nicht selektieren.

Hat hier jemand eine Idee?

 

[SuperFamicom]

Hat keiner 'ne Idee?

 

[thet1983]

wie sollte dir jemand helfen wenn du keinen code bereit stellst??

 

[SuperFamicom]

Hab da eher nach allgemeinen Lösungsansätzen gefragt.
Aber um konkreter zu werden, hier der Code:

public class CheckableTreeFrame extends JFrame {

    private JTree tree;

    public CheckableTreeFrame() {
        initComponents();
        initListeners();
    }

    private void initComponents() {
        this.setSize(new Dimension(480, 512));   
        this.setLayout(new BorderLayout());
   
        tree = new JTree();
        tree.setRootVisible(false);
        tree.setCellRenderer(new CheckTreeRenderer());
   
        this.add(tree);
    }

    private void initListeners() {
   
    }

    public static void main(String[] args) {
        CheckableTreeFrame frame = new CheckableTreeFrame();
        frame.setVisible(true);
    }

    class CheckTreeRenderer extends DefaultTreeCellRenderer {
   
        JPanel panel;
        JCheckBox checkBox;   
        JRadioButton radioButton;   
        ButtonGroup buttonGroup;
   
        public CheckTreeRenderer() {
            super();
            setOpaque(false);
            setLayout(new BorderLayout());      
       
            radioButton = new JRadioButton();                   
            radioButton.setOpaque(false);
            checkBox = new JCheckBox();
            checkBox.setOpaque(false);
       
            buttonGroup = new ButtonGroup();       
            buttonGroup.add(radioButton);
       
            panel = new JPanel();
            panel.setOpaque(false);
            panel.setLayout(new FlowLayout(0, 0, FlowLayout.LEFT));
            panel.add(radioButton);
            panel.add(checkBox);
        }

        @Override
        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
            super.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);
       
            if ("blue".equals(value.toString())) {
                checkBox.setText("blue");
                return panel;
            } else if ("red".equals(value.toString())) {
                checkBox.setText("red");
                return panel;
            }
            return this;       
        }
    }
}

 

[thet1983]

Ich denke du solltest anfragen ob es selected ist dann sollte es eigentlich funktionieren

if(selected){
   //....
}

 

[SuperFamicom]

Das Problem ist, dass selected sich auf einen selektierten Knoten bezieht. Der Knoten enthält aber zwei Komponenten, die unabhängig voneinander selektiert werden sollen, je nach dem ob auf dem RadioButton oder der CheckBox geklickt wurde.

 

[Harry Kane]

Kannst du die Checkboxen nicht auswählen, oder zeigen sie nicht den gewünschten Status des Knotens an?

 

[SuperFamicom]

Die Checkboxen können nicht ausgewählt (sprich gechecked) werden. Gleiches gilt für die RadioButtons.

 

[thet1983]

Hab gestern noch etwas rumgespielt...bin aber nur auf folgende lösung gekommen ( nur mit checkbox) vl hift dir das weiter.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeCellRenderer;

/**
* 2016 © SiCuSoft
*
* @author etzelsdorfer Thomas
*/
public class JTreeCellRenderDemo {
    // constructor
    public JTreeCellRenderDemo(){
        super();
    }
    // build frame
    public void createFrame(){
        JFrame f = new JFrame("Demo");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JTree tree = new JTree(getRoot());
        tree.setCellRenderer(new MyCellRender());
        f.getContentPane().add(tree, BorderLayout.CENTER);
        f.setVisible(true);
    }
    // returns the root
    public DefaultMutableTreeNode getRoot(){
        DefaultMutableTreeNode root = new DefaultMutableTreeNode("THIS IS THE ROOT");
       
        DefaultMutableTreeNode node1 = new DefaultMutableTreeNode("NODE 1");
        DefaultMutableTreeNode node2 = new DefaultMutableTreeNode("NODE 2");
        DefaultMutableTreeNode node3 = new DefaultMutableTreeNode("NODE 3");
       
        root.add(node1);root.add(node2);root.add(node3);
        return root;
    }
    // Main
    public static void main(String[] args) {
        JTreeCellRenderDemo d = new JTreeCellRenderDemo();
        d.createFrame();
    }
}
// TreeCellRender Class
class MyCellRender extends JCheckBox implements TreeCellRenderer {

    public MyCellRender() {
        super();
    }
    @Override
    public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {

        setText(value.toString());
        setSelected(false);
        if (selected) {
            setSelected(true);
            setBackground(Color.RED);
            setForeground(Color.WHITE);
        } else {
            setSelected(false);
            setForeground(Color.WHITE);
            setBackground(Color.BLACK);
        }
        return this;
    }
}

 

[SuperFamicom]

1. Die Checkboxen können zwar in deinem Codebeispiel selektiert werden, funktionieren jedoch wie Radiobuttons innerhalb des parent nodes. Sie sollten schon wie Checkboxen funktionieren, d.h. beliebig viele Checkboxen sollen innerhalb des parent nodes selektierbar sein.
2. Die eigentliche Idee war, Checkboxes und Radiobuttons zusammen in einem Knoten funktionierend unterzubringen. In deinem Beispiel erweiterst du den Renderer mit JCheckBox. Erweitert man allerdings den Renderer mit einem JPanel, dass sowohl JCheckBox als auch JRadioButton beinhaltet, kommt man an den Punkt, wo ich mein eigentliches Problem habe: weder Checkboxen noch Radiobuttons sind selektierbar.

 

[thet1983]

das kommt von nicht richtig lesen
hab mir gedacht entweder oder...

 

[Harry Kane]

Mich wundert es etwas, dass die JCheckBoxen anwählbar sind. Ich hatte den ganzen Renderer-Kram so verstanden, dass die Component quasi nur als eine Art "Stempel" verwendet wird, so dass das, was im Baum angezeigt wird, gar nicht die Component selber ist, sondern nur der Abdruck, den sie hinterlassen hat, als sie vom JTree gezeichnet wurde. Ansonsten wäre es ja sehr schwierig, in der getTreeCellRendererComponent-Methode immer dieselbe Instanz zurückzugeben.
Wenn du Knoten interaktiv ändern möchtest, musst du dich wohl mit dem Thema TreeCellEditor befassen.

 

[SuperFamicom]

Ah, okay. Dann schau ich da mal rein.

Vielen Dank!

 

[SuperFamicom]

Über den TreeCellEditor funktioniert das schon etwas besser:

Was mich allerdings noch stört:

1. Die Checkboxen funktionieren wie RadioButtons, d.h. es lässt sich immer nur eine Checkbox selektieren, während die zuvor selektierte CheckBox deselektiert wird.
2. Klickt man auf den RadioButton wird auch gleichzeitig die CheckBox in der gleichen row mitselektiert, bzw. andersrum: Klickt man auf die CheckBox, wird auch der RadioButton der gleichen row mitselektiert.
   
3. Klickt man ins "Leere", d.h. außerhalb der Knoten, wird alles deselektiert.

Wünschenswert wäre:

1. Wird der Label angeklickt, wird lediglich der Knoten markiert. Dies soll später PopupMenu ermöglichen, ohne dabei was versehentlich zu selektieren/deselektieren.
   
2. Beliebig viele Checkboxen sollen selektierbar sein.
3. Wird der RadioButton geklickt, soll auch nur der RadioButton selektiert werden und nicht die CheckBox in der gleichen row, bzw. andersrum.
4. Wird außerhalb der Tabelle geklickt, bleiben sämtliche Selektionen erhalten.

Hat jemand Ideen, wie die oben (hoffentlich verständlich) geschilderte Punkte umgesetzt werden können?

Der bisherige Code hierzu:

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.util.Vector;
import javax.swing.AbstractCellEditor;
import javax.swing.ButtonGroup;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTree;
import javax.swing.UIManager;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreeCellEditor;
import javax.swing.tree.TreeCellRenderer;

public class CheckableTree extends JFrame {
 
    private JTree tree;
 
    private ButtonGroup group = new ButtonGroup();
 
    public CheckableTree() {
        initComponents();
    }
 
    private void initComponents() {
        this.setSize(new Dimension(480, 512));     
        this.setLayout(new BorderLayout());

        Node colorNodes[] = {
            new Node("blue", false, false),
            new Node("violet", false, false),
            new Node("red", false, false),
            new Node("yellow", false, false)
        };             
        NamedVector parentNode = new NamedVector("colors", colorNodes);             
        NamedVector rootNode = new NamedVector("root", new Object[] {parentNode});     
     
        tree = new JTree(rootNode);
        tree.setRootVisible(false);
        tree.setEditable(true);
        tree.setCellRenderer(new NodeRenderer(group));
     
        tree.setCellEditor(new CheckTreeEditor(group));
        tree.setEditable(true);
                             
        this.add(tree);     
    }
 
    public static void main(String[] args) {
        CheckableTree frame = new CheckableTree();
        frame.setVisible(true);
    }
 
 
    class Node extends DefaultMutableTreeNode {
     
        String text;
        boolean isCheckBoxChecked = false;
        boolean isRadioButtonChecked = false;
     
        public Node(String text, boolean isCheckBoxChecked, boolean isRadioButtonChecked) {         
            this.text = text;
            this.isCheckBoxChecked = isCheckBoxChecked;
            this.isRadioButtonChecked = isRadioButtonChecked;
        }
    }
 
    class RendererComponent extends JPanel {
     
        JCheckBox checkBox = new JCheckBox();
        JRadioButton radioButton = new JRadioButton();
        JLabel label = new JLabel();
     
        public RendererComponent() {
            setLayout(new FlowLayout(0, 0, FlowLayout.LEFT));         
            add(radioButton);         
            add(checkBox);
            add(label);
        }
    }
 
    class NodeRenderer implements TreeCellRenderer {
     
        DefaultTreeCellRenderer defaultRenderer = new DefaultTreeCellRenderer();
        RendererComponent renderer = new RendererComponent();
        ButtonGroup group;
     
        public NodeRenderer(ButtonGroup group) {
            this.group = group;         
            this.group.add(renderer.radioButton);
         
            Boolean drawFocusBorder = (Boolean) UIManager.get("Tree.drawsFocusBorderAroundIcon");
            renderer.checkBox.setFocusPainted((drawFocusBorder != null) && drawFocusBorder.booleanValue());
            renderer.radioButton.setFocusPainted((drawFocusBorder != null) && drawFocusBorder.booleanValue());
         
        }
     
        @Override
        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
            Component treeRenderer;                     
                         
            if (leaf) {
                String text = tree.convertValueToText(value, selected, expanded, leaf, row, false);
                renderer.label.setText(text);
                renderer.checkBox.setSelected(false);
                renderer.radioButton.setSelected(false);
             
                renderer.setEnabled(tree.isEnabled());
             
                if (selected) {
                    renderer.setForeground(UIManager.getColor("Tree.selectionForeground"));
                    renderer.setBackground(UIManager.getColor("Tree.selectionBackground"));
                } else {
                    renderer.setForeground(UIManager.getColor("Tree.textForeground"));
                    renderer.setBackground(UIManager.getColor("Tree.textBackground"));
                }
             
                if ((value != null) && (value instanceof DefaultMutableTreeNode)) {
                    Object userObject = ((DefaultMutableTreeNode) value).getUserObject();
                    if (userObject instanceof Node) {
                        Node node = (Node) userObject;
                        renderer.label.setText(node.text);
                        renderer.checkBox.setSelected(node.isCheckBoxChecked);
                        renderer.radioButton.setSelected(node.isRadioButtonChecked);
                    }
                }             
                treeRenderer = renderer;
            } else {
                treeRenderer = defaultRenderer.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);
            }
        
            return treeRenderer;
        }

    }
 
 
    class CheckTreeEditor extends AbstractCellEditor implements TreeCellEditor {             
     
        private final NodeRenderer renderer;                            
     
        public CheckTreeEditor(ButtonGroup group) {
            renderer = new NodeRenderer(group);
        }

        @Override
        public Object getCellEditorValue() {
            JCheckBox checkBox = renderer.renderer.checkBox;
            JRadioButton radioButton = renderer.renderer.radioButton;
            JLabel label = renderer.renderer.label;
            Node node = new Node(label.getText(), checkBox.isSelected(), radioButton.isSelected());         
            return node;
        }             
     
        @Override
        public Component getTreeCellEditorComponent(JTree tree, Object value, boolean isSelected, boolean expanded, boolean leaf, int row) {
            Component editor = renderer.getTreeCellRendererComponent(tree, value, true, expanded, leaf, row, true);
            return editor;
        }
    }
 
    class NamedVector extends Vector {
     
        String name;
     
        public NamedVector(String name, Object elements[]) {
            this.name = name;
            for (int i = 0, n = elements.length; i < n; i++) {
                add(elements[i]);
            }
        }
     
        @Override
        public String toString() {
            return name;
        }
    }
}

 

[SuperFamicom]

Ich hab die angerissenen Probleme soweit gelöst. Dennoch machen die RadioButtons nach wie vor Probleme. Beim Versuch, sie in einer ButtonGroup unterzubringen (CheckTreeEditor-Konstruktor), kommt es zum Fehlverhalten: sie lassen sich alle selektieren, aber nicht mehr deselektieren.

Wenn hier jemand aushelfen könnte, wäre ich echt dankbar.

Hier der neue Code:

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Vector;
import javax.swing.AbstractAction;
import javax.swing.AbstractButton;
import javax.swing.AbstractCellEditor;
import javax.swing.Action;
import javax.swing.ButtonGroup;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTree;
import javax.swing.UIManager;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreeCellEditor;
import javax.swing.tree.TreeCellRenderer;

public class CheckableTree extends JFrame {
 
    private JTree tree;
 
    private final ButtonGroup group = new ButtonGroup();
 
    public CheckableTree() {
        initComponents();
    }
 
    private void initComponents() {
        this.setSize(new Dimension(480, 512));    
        this.setLayout(new BorderLayout());
        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
     
        Node[] colorNodes = {
            new Node("blue", false, true),
            new Node("violet", false, false),
            new Node("red", false, false),
            new Node("yellow", false, false)
        };            
        NamedVector parentNode = new NamedVector("colors", colorNodes);            
        NamedVector rootNode = new NamedVector("root", new Object[] {parentNode});    
     
        tree = new JTree(rootNode);
        tree.setRootVisible(false);

        tree.setCellRenderer(new NodeRenderer(group));
     
        tree.setCellEditor(new CheckTreeEditor(group));
        tree.setEditable(true);
                             
        this.add(tree);    
    }
 
    public static void main(String[] args) {
        CheckableTree frame = new CheckableTree();
        frame.setVisible(true);
    }
 
     
    class Node extends DefaultMutableTreeNode {
     
        String text;
        boolean isCheckBoxChecked = false;
        boolean isRadioButtonChecked = false;                      
     
        public Node(String text, boolean isCheckBoxChecked, boolean isRadioButtonChecked) {
            this.text = text;
            this.isCheckBoxChecked = isCheckBoxChecked;
            this.isRadioButtonChecked = isRadioButtonChecked;
        }            
    }
 
    class RendererComponent extends JPanel {
     
        JCheckBox checkBox = new JCheckBox();
        JRadioButton radioButton = new JRadioButton();
        JLabel label = new JLabel();
     
        public RendererComponent() {
            setLayout(new FlowLayout(0, 0, FlowLayout.LEFT));
            add(radioButton);        
            add(checkBox);
            add(label);
        }
    }
 
    class NodeRenderer implements TreeCellRenderer {
     
        DefaultTreeCellRenderer defaultRenderer = new DefaultTreeCellRenderer();
        RendererComponent renderer = new RendererComponent();
        ButtonGroup group;
     
        public NodeRenderer(ButtonGroup group) {
            this.group = group;
         
            Boolean drawFocusBorder = (Boolean) UIManager.get("Tree.drawsFocusBorderAroundIcon");
            renderer.checkBox.setFocusPainted((drawFocusBorder != null) && drawFocusBorder.booleanValue());
            renderer.radioButton.setFocusPainted((drawFocusBorder != null) && drawFocusBorder.booleanValue());         
        }
     
        @Override
        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
            Component treeRenderer;                    
                         
            if (leaf) {
                String text = tree.convertValueToText(value, selected, expanded, leaf, row, false);
                renderer.label.setText(text);
                renderer.checkBox.setSelected(false);
                renderer.radioButton.setSelected(false);
             
                renderer.setEnabled(tree.isEnabled());
             
                if (selected) {
                    renderer.setForeground(UIManager.getColor("Tree.selectionForeground"));
                    renderer.setBackground(UIManager.getColor("Tree.selectionBackground"));
                } else {
                    renderer.setForeground(UIManager.getColor("Tree.textForeground"));
                    renderer.setBackground(UIManager.getColor("Tree.textBackground"));
                }                            
             
                if ((value != null) && (value instanceof DefaultMutableTreeNode)) {                                                        
                 
                    Object userObject = ((DefaultMutableTreeNode) value).getUserObject();
                    if (userObject instanceof Node) {
                        Node node = (Node) userObject;
                        renderer.label.setText(node.text);
                        renderer.checkBox.setSelected(node.isCheckBoxChecked);
                        renderer.radioButton.setSelected(node.isRadioButtonChecked);
                    }
                }
                treeRenderer = renderer;
            } else {
                treeRenderer = defaultRenderer.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);
            }
       
            return treeRenderer;
        }

    }
 
 
    class CheckTreeEditor extends AbstractCellEditor implements TreeCellEditor {            
     
        private final NodeRenderer renderer;                            
             
     
        public CheckTreeEditor(ButtonGroup group) {        
            renderer = new NodeRenderer(group);          
            group.add(renderer.renderer.radioButton);
            renderer.renderer.checkBox.setAction(createAction("check"));
            renderer.renderer.radioButton.setAction(createAction("radio"));
        }
     
        private Action createAction(final String actionCommand) {
            Action action = new AbstractAction("") {
             
                @Override
                public void actionPerformed(ActionEvent e) {
                    stopEditing(actionCommand);
                }                    
            };
            return action;
        }
     
        protected void stopEditing(String actionCommand) {
            stopCellEditing();
        }

        @Override
        public Object getCellEditorValue() {                    
            JRadioButton radioButton = renderer.renderer.radioButton;           
            JCheckBox checkBox = renderer.renderer.checkBox;
            JLabel label = renderer.renderer.label;        
            return new Node(label.getText(), checkBox.isSelected(), radioButton.isSelected());
        }
     
        @Override
        public Component getTreeCellEditorComponent(JTree tree, Object value, boolean isSelected, boolean expanded, boolean leaf, int row) {
            Component editor = renderer.getTreeCellRendererComponent(tree, value, true, expanded, leaf, row, true);                                
            return editor;
        }
    }
 
    class NamedVector extends Vector {
     
        String name;
     
        public NamedVector(String name, Object elements[]) {
            this.name = name;
            for (int i = 0, n = elements.length; i < n; i++) {
                add(elements[i]);
            }
        }
     
        @Override
        public String toString() {
            return name;
        }
    }
}