Issue with Swing JTree Checkbox Behavior

Question

Facing this issue with my code while working with checkboxes in a JTree. The root node is treated as a "Named Vector" in first iteration instead of a "CheckBoxNode"As a result, it doesn't iterate through its child checkboxes.

In the second iteration, the root node becomes a "CheckBoxNode," causing all child checkboxes to be selected, but they should already be selected and instead should be deselected:

Second Iteration and Second Click:

Result:

JanelaPrincipal.java:

package br.josueborges.principal;

import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.util.List;
import javax.swing.tree.*;

public class JanelaPrincipal {

    private JFrame frame;
    private JTree tree;

    public JanelaPrincipal() {
        initialize();
    }

    public static void main(String[] args) {
        EventQueue.invokeLater(() -> {
            try {
                JanelaPrincipal window = new JanelaPrincipal();
                window.frame.setVisible(true);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }

    private void initialize() {
        
        frame = new JFrame();
        frame.setBounds(100, 100, 400, 400);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().setLayout(new BorderLayout());

        DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root");

        DefaultMutableTreeNode folder1 = new DefaultMutableTreeNode("Folder 1");
        DefaultMutableTreeNode folder2 = new DefaultMutableTreeNode("Folder 2");

        DefaultMutableTreeNode file1 = new DefaultMutableTreeNode("File 1");
        DefaultMutableTreeNode file2 = new DefaultMutableTreeNode("File 2");
        DefaultMutableTreeNode file3 = new DefaultMutableTreeNode("File 3");

        root.add(folder1);
        root.add(folder2);

        folder1.add(file1);
        folder2.add(file2);
        folder2.add(file3);

        Map<String, List<String>> pacotesEArquivos = new HashMap<>();
        
        List<String> nodes = new ArrayList<>();
        Enumeration<?> enumeration = root.breadthFirstEnumeration();
        while (enumeration.hasMoreElements()) {
            DefaultMutableTreeNode node = (DefaultMutableTreeNode) enumeration.nextElement();
            if (node.isLeaf()) {
                nodes.add(node.toString());
            }
        }
        pacotesEArquivos.put("Root", nodes);

        tree = new CheckBoxNodeTreeSample().retornaJTree(pacotesEArquivos);
        JScrollPane scrollPane = new JScrollPane(tree);
        frame.getContentPane().add(scrollPane, BorderLayout.CENTER);
    }
}

CheckBoxNode.java:

package br.josueborges.principal;

import java.awt.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseEvent;
import java.util.EventObject;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import java.util.*;

import javax.swing.AbstractCellEditor;
import javax.swing.JCheckBox;
import javax.swing.JTree;
import javax.swing.UIManager;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeCellEditor;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreePath;

public class CheckBoxNodeTreeSample {

    public CheckBoxNodeTreeSample() {

    }

    public JTree retornaJTree(Map<String, List<String>> pacotesEArquivos) {

        ArrayList<Vector<Object>> vetores = new ArrayList<Vector<Object>>();

        for (Map.Entry<String, List<String>> entry : pacotesEArquivos.entrySet()) {
            String pacote = entry.getKey();
            pacote = pacote.substring(1);

            System.out.println("Pacote: " + pacote);
            List<String> nomesArquivos = entry.getValue();

            CheckBoxNode checkBoxNode[] = new CheckBoxNode[nomesArquivos.size()];

            // String nomeArquivo : nomesArquivos
            for (int i = 0; i < nomesArquivos.size(); i++) {
                checkBoxNode[i] = new CheckBoxNode(nomesArquivos.get(i), false);
            }

            Vector<Object> vetorDoJTree = new NamedVector(pacote, checkBoxNode);

            vetores.add(vetorDoJTree);
        }

        CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();

        Object rootNodes[] = new Object[pacotesEArquivos.size()];

        for (int i = 0; i < vetores.size(); i++) {
            rootNodes[i] = vetores.get(i);
        }

        Vector<Object> rootVector = new NamedVector("Teste", rootNodes);

        JTree tree = new JTree(rootVector);

        tree.setVisibleRowCount(50);
        tree.setRootVisible(false);
        tree.setShowsRootHandles(true);

        tree.setCellRenderer(renderer);
        tree.setCellEditor(new CheckBoxNodeEditor(tree));
        tree.setEditable(true);

        return tree;
    }
}

class CheckBoxNodeRenderer implements TreeCellRenderer {

    private JCheckBox leafRenderer = new JCheckBox();
    private Color selectionForeground, selectionBackground, textForeground, textBackground;

    protected JCheckBox getLeafRenderer() {
        return leafRenderer;
    }

    public CheckBoxNodeRenderer() {
        Font fontValue;
        fontValue = UIManager.getFont("Tree.font");
        if (fontValue != null) {
            leafRenderer.setFont(fontValue);
        }
        Boolean booleanValue = (Boolean) UIManager.get("Tree.drawsFocusBorderAroundIcon");
        System.out.println("booleanValue: " + booleanValue);
        leafRenderer.setFocusPainted((booleanValue != null) && (booleanValue.booleanValue()));
        UIManager.getColor("Tree.selectionBorderColor");
        selectionForeground = UIManager.getColor("Tree.selectionForeground");
        selectionBackground = UIManager.getColor("Tree.selectionBackground");
        textForeground = UIManager.getColor("Tree.textForeground");
        textBackground = UIManager.getColor("Tree.textBackground");
    }

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

        Component returnValue;
        
        String stringValue = tree.convertValueToText(value, selected, expanded, leaf, row, false);
        leafRenderer.setText(stringValue);
        leafRenderer.setSelected(false);
        leafRenderer.setEnabled(tree.isEnabled());
        if (selected) {
            leafRenderer.setForeground(selectionForeground);
            leafRenderer.setBackground(selectionBackground);
        } else {
            leafRenderer.setForeground(textForeground);
            leafRenderer.setBackground(textBackground);
        }
        if ((value != null) && (value instanceof DefaultMutableTreeNode)) {
            Object userObject = ((DefaultMutableTreeNode) value).getUserObject();
            if (userObject instanceof CheckBoxNode) {
                CheckBoxNode node = (CheckBoxNode) userObject;
                leafRenderer.setText(node.getText());
                leafRenderer.setSelected(node.isSelected());
            }
        }
        returnValue = leafRenderer;
        
        return returnValue;
    }
}

class CheckBoxNodeEditor extends AbstractCellEditor implements TreeCellEditor {

    private static final long serialVersionUID = 1L;
    private CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();
    private JTree tree;

    public CheckBoxNodeEditor(JTree tree) {
        this.tree = tree;
    }

    @Override
    public Object getCellEditorValue() {
        JCheckBox checkbox = renderer.getLeafRenderer();
        CheckBoxNode checkBoxNode = new CheckBoxNode(checkbox.getText(), checkbox.isSelected());
        return checkBoxNode;
    }

    @Override
    public boolean isCellEditable(EventObject event) {
        boolean returnValue = false;
        if (event instanceof MouseEvent) {
            MouseEvent mouseEvent = (MouseEvent) event;
            TreePath path = tree.getPathForLocation(mouseEvent.getX(), mouseEvent.getY());
            if (path != null) {
                Object node = path.getLastPathComponent();
                if ((node != null) && (node instanceof DefaultMutableTreeNode)) {
                    DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) node;
                    Object userObject = treeNode.getUserObject();
                    returnValue = true;
                }
            }
        }
        return returnValue;
    }

    @Override
    public Component getTreeCellEditorComponent(JTree tree, Object value, boolean selected, boolean expanded,
            boolean leaf, int row) {

        Component editor = renderer.getTreeCellRendererComponent(tree, value, true, expanded, leaf, row, true);
        
        ItemListener itemListener = new ItemListener() {
            @Override
            public void itemStateChanged(ItemEvent itemEvent) {
                if (stopCellEditing()) {
                    fireEditingStopped();
                }
            }
        };
        if (editor instanceof JCheckBox) {
            JCheckBox checkBox = (JCheckBox) editor;
            checkBox.removeItemListener(itemListener);
            checkBox.addItemListener(itemListener);

            // Ao clicar no checkbox, atualizar o estado de todos os checkboxes filhos e pais
            DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
            Object userObject = node.getUserObject();
            if (userObject instanceof CheckBoxNode) {
                
                CheckBoxNode parentNode = (CheckBoxNode) userObject;
                boolean parentSelected = checkBox.isSelected();

                // Percorrer os nós filhos (arquivos) e definir o mesmo estado do checkbox pai
                for (int i = 0; i < node.getChildCount(); i++) {
                    DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) node.getChildAt(i);
                    Object childUserObject = childNode.getUserObject();
                    if (childUserObject instanceof CheckBoxNode) {
                        CheckBoxNode childCheckBoxNode = (CheckBoxNode) childUserObject;
                        childCheckBoxNode.setSelected(parentSelected);
                    }
                }

                // Atualizar o estado dos nós pais
                updateParentNodes(node, parentSelected);

                // Notificar a árvore que houve mudança no modelo
                ((DefaultTreeModel) tree.getModel()).nodeStructureChanged(node);
          }
        }
        return editor;
    }

// Método para atualizar o estado dos nós pais
    private void updateParentNodes(DefaultMutableTreeNode node, boolean selected) {
        DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode) node.getParent();
        if (parentNode != null) {
            Object parentUserObject = parentNode.getUserObject();
            if (parentUserObject instanceof CheckBoxNode) {
                CheckBoxNode parentCheckBoxNode = (CheckBoxNode) parentUserObject;

                // Verificar se todos os filhos estão selecionados e atualizar o estado do nó
                // pai
                boolean allChildrenSelected = true;
                for (int i = 0; i < parentNode.getChildCount(); i++) {
                    DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) parentNode.getChildAt(i);
                    Object childUserObject = childNode.getUserObject();
                    if (childUserObject instanceof CheckBoxNode) {
                        CheckBoxNode childCheckBoxNode = (CheckBoxNode) childUserObject;
                        if (!childCheckBoxNode.isSelected()) {
                            allChildrenSelected = false;
                            break;
                        }
                    }
                }

                parentCheckBoxNode.setSelected(allChildrenSelected);

                // Continuar atualizando os nós pais recursivamente
                updateParentNodes(parentNode, selected);
            }
        }
    }
}

class CheckBoxNode {

    private String text;
    private boolean selected;

    public CheckBoxNode(String text, boolean selected) {
        this.text = text;
        this.selected = selected;
    }

    public boolean isSelected() {
        return selected;
    }

    public void setSelected(boolean newValue) {
        selected = newValue;
    }

    public String getText() {
        return text;
    }

    public void setText(String newValue) {
        text = newValue;
    }

    @Override
    public String toString() {
        return getClass().getName() + "[" + text + "/" + selected + "]";
    }
}

class NamedVector extends Vector<Object> {

    private static final long serialVersionUID = 1L;
    private String name;

    public NamedVector(String name) {
        super(); 
        this.name = 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 + "]";
    }
}

Answer 1

I'm not going to try and fix your code, it's moving in the wrong direction for what you seem to be trying to achieve, instead, I've modified this example to add support for updating the child nodes when the parent node state changes.

import java.awt.Component;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import javax.swing.AbstractCellEditor;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.UIManager;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeCellEditor;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;

public class Main {

    public static void main(String[] args) {
        new Main();
    }

    public Main() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                JTree tree = createTree();
                tree.setToggleClickCount(0);
                tree.setCellRenderer(new StateRenderer());
                tree.setCellEditor(new StateEditor());
                tree.setEditable(true);

                JFrame f = new JFrame();
                f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                f.add(new JScrollPane(tree));

                f.pack();
                f.setLocationRelativeTo(null);
                f.setVisible(true);
            }
        });
    }

    private JTree createTree() {
        int children = 4;
        int grandChildren = 2;
        DefaultMutableTreeNode root = new DefaultMutableTreeNode(new State("Films", false));
        DefaultMutableTreeNode node;

        String[] cat = {"Sci-Fi", "Fantasy", "Action", "Comedy"};
        String[][] films = {
            {"Star Wars", "Star Trek"},
            {"Lord of the Rings", "Conan"},
            {"Terminator", "Transformers"},
            {"Cheaper by the Doze", "Father of the Bride"}
        };
        for (int j = 0; j < children; j++) {
            node = new DefaultMutableTreeNode(new State(cat[j], false));
            root.add(node);
            for (int k = 0; k < grandChildren; k++) {
                node.add(new DefaultMutableTreeNode(new State(films[j][k], false)));
            }
        }
        TestModel model = new TestModel(root);
        return new JTree(model);
    }

    public class State {

        private String text;
        private boolean selected;

        public State(String text, boolean selected) {
            this.text = text;
            this.selected = selected;
        }

        public String getText() {
            return text;
        }

        public boolean isSelected() {
            return selected;
        }

        public void setSelected(boolean selected) {
            this.selected = selected;
        }

    }

    public class StateEditor extends AbstractCellEditor implements TreeCellEditor {

        //JPanel panel;
        private JCheckBox checkBox;

        private State editorValue;

        public StateEditor() {
            checkBox = new JCheckBox();
            checkBox.setOpaque(false);
            // This seems to be important :/
            checkBox.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    stopCellEditing();
                }
            });
        }

        @Override
        public Object getCellEditorValue() {
            editorValue.setSelected(checkBox.isSelected());
            return editorValue;
        }

        @Override
        public Component getTreeCellEditorComponent(JTree tree, Object value, boolean isSelected, boolean expanded, boolean leaf, int row) {
            if (value instanceof DefaultMutableTreeNode) {
                DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
                State state = (State) node.getUserObject();
                editorValue = state;
                checkBox.setText(state.getText());
                checkBox.setSelected(state.isSelected());
            } else {
                checkBox.setText("??");
                checkBox.setSelected(false);
            }

            return checkBox;

        }

    }

    public class StateRenderer implements TreeCellRenderer {

        private JCheckBox checkBox;

        public StateRenderer() {
            checkBox = new JCheckBox();
            checkBox.setOpaque(false);
        }

        @Override
        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
            if (value instanceof DefaultMutableTreeNode) {
                DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
                State state = (State) node.getUserObject();
                checkBox.setText(state.getText());
                checkBox.setSelected(state.isSelected());
            } else {
                checkBox.setText("??");
                checkBox.setSelected(false);
            }

            if (selected) {
                checkBox.setBackground(UIManager.getColor("Tree.selectionBackground"));
                checkBox.setForeground(UIManager.getColor("Tree.selectionForeground"));
            } else {
                checkBox.setForeground(tree.getForeground());
                checkBox.setBackground(null);
            }

            checkBox.setOpaque(selected);

            return checkBox;
        }
    }

    public class TestModel extends DefaultTreeModel {
        public TestModel(TreeNode root) {
            super(root);
        }

        @Override
        public void valueForPathChanged(TreePath path, Object newValue) {
            // This is important, as it fires the nodeChanged event
            super.valueForPathChanged(path, newValue);
            Object lastPathComponent = path.getLastPathComponent();
            if (!(lastPathComponent instanceof DefaultMutableTreeNode)) {
                return;
            }
            DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode) lastPathComponent;
            if (parentNode.isLeaf()) {
                return;
            }

            State state = stateFrom(parentNode);
            StateChangeModel model = new StateChangeModel();
            updateState(parentNode, state, model);

            fireTreeNodesChanged(this, model.getPaths(), model.getIndicies(), model.getChildren());
        }

        protected State stateFrom(TreeNode node) {
            if (!(node instanceof DefaultMutableTreeNode)) {
                return null;
            }
            DefaultMutableTreeNode defaultNode = (DefaultMutableTreeNode) node;
            Object userObject = defaultNode.getUserObject();
            if (!(userObject instanceof State)) {
                // Here, if you're clever, you could check the
                // state of all the nodes of this node's parent
                // and if they're all selected, mark the parent
                // nodes as selected as well
                return null;
            }
            return (State) userObject;
        }

        protected void updateState(DefaultMutableTreeNode parentNode, State state, StateChangeModel model) {
            for (int index = 0; index < parentNode.getChildCount(); index++) {
                TreeNode childNode = parentNode.getChildAt(index);
                if (!(childNode instanceof DefaultMutableTreeNode)) {
                    continue;
                }
                DefaultMutableTreeNode defaultChildNode = (DefaultMutableTreeNode) childNode;
                Object childObject = defaultChildNode.getUserObject();
                if (!(childObject instanceof State)) {
                    return;
                }
                State childState = (State) childObject;
                childState.setSelected(state.isSelected());

                model.add(new TreePath(getPathToRoot(childNode)), index, childNode);
                // Recursive update...
                updateState(defaultChildNode, state, model);
            }
        }

        protected class StateChangeModel {
            List<TreePath> paths = new ArrayList<>(8);
            List<Integer> indicies = new ArrayList<>(8);
            List<Object> children = new ArrayList<>(8);            

            public void add(TreePath path, int index, TreeNode child) {
                paths.add(path);
                indicies.add(index);
                children.add(child);
            }

            public TreePath[] getPaths() {
                return paths.toArray(new TreePath[paths.size()]);
            }

            public int[] getIndicies() {
                return indicies.stream().mapToInt(i -> i).toArray();
            }

            public Object[] getChildren() {
                return children.toArray(new Object[children.size()]);
            }
        }
    }
}

Now, it's important to note a couple of things...

1. It's VERY important that you call stopCellEditing on the TreeCellEditor when the state changes, otherwise this will NOT work. I don't know why, but that's the way it needs to work.
2. I've made use of a custom DefaultTreeModel and overridden the valueForPathChanged method. This is VERY important, as it's how the model gets notified that the state of a node was changed by the editor. Otherwise you're going to need to spend a lot of time with TreeModelListener and spend a lot of time writing a lot of dirty code.
3. You're current direction/implementation is fundamentally flawed for what you seem to be trying to do, I suggest spending some time studying the above example and trying to move your code to it.

still one issue in the children ones

Seems to be working find for me: