title: Mouse Listener in Custom Swing Component Intermittently Firing
body: <p>I have a custom JCheckboxTree Component that extends JTree I adapted from <a href="https://stackoverflow.com/questions/21847411/java-swing-need-a-good-quality-developed-jtree-with-checkboxes">Java Swing: Need a good quality developed JTree with checkboxes</a>. However when i run the program clicking one of the checkbox in the tree only fires the mouseClicked() function from the MouseListener about 50% of the time. It usually works after 2 clicks but sometimes works on the first. There doesn't seem to be any consistency.</p>
  <p>I have tried adding a breakpoint at the first line of the mouseclicked() event with <code>TreePath tp = selfPointer.getPathForLocation(arg0.getX(), arg0.getY());</code> and can see that it is not hitting the breakpoint on some clicks so i know the event isn't always firing. A screenshot of the component in my application is below and the code i'm using. I'm very new to Swing and am just trying to get the clicks working. Any help is appreciated!</p>
  <p><a href="https://i.stack.imgur.com/1GLjs.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/1GLjs.png" alt="enter image description here" /></a></p>
  <p>Calling code:</p>
  <pre><code>   //from the code setting my new JFrame
     JCheckboxTree jCheckboxTree = new JCheckboxTree(buildTreeModel());
     addEntryCheckListeners(jCheckboxTree);
  
  -------------------------------------------
  
   //a private helper later
   private void addEntryCheckListeners(JCheckboxTree checkboxTree) {
          checkboxTree.addCheckChangeEventListener(event -&gt; {
              checkedModules.clear();
              Arrays.stream(checkboxTree.getCheckedPaths())
                      .map(TreePath::getLastPathComponent)
                      .map(o -&gt; (DefaultMutableTreeNode) o)
                      .filter(DefaultMutableTreeNode::isLeaf)
                      .map(Objects::toString)
                      .forEach(checkedModules::add);
  
              boolean readyToDeploy = !deployInProgress.get(); //&amp;&amp; checkedModules.size() &gt; 0;
              deployButton.setEnabled(readyToDeploy);
              testOnlyButton.setEnabled(readyToDeploy);
          });
  </code></pre>
  <p>The JCheckboxTree code:</p>
  <pre><code>package ui;
  
  import javax.swing.JCheckBox;
  import javax.swing.JPanel;
  import javax.swing.JTree;
  import javax.swing.event.EventListenerList;
  import javax.swing.tree.DefaultMutableTreeNode;
  import javax.swing.tree.DefaultTreeSelectionModel;
  import javax.swing.tree.TreeCellRenderer;
  import javax.swing.tree.TreeModel;
  import javax.swing.tree.TreeNode;
  import javax.swing.tree.TreePath;
  import java.awt.BorderLayout;
  import java.awt.Component;
  import java.awt.Dimension;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
  import java.util.EventListener;
  import java.util.EventObject;
  import java.util.HashMap;
  import java.util.HashSet;
  
  /**
   * Adapted from https://stackoverflow.com/questions/21847411/java-swing-need-a-good-quality-developed-jtree-with-checkboxes
   */
  public class JCheckboxTree extends JTree {
  
      // Defining a new event type for the checking mechanism and preparing event-handling mechanism
      protected EventListenerList listenerList = new EventListenerList();
      JCheckboxTree selfPointer = this;
      HashMap&lt;TreePath, CheckedNode&gt; nodesCheckingState;
      HashSet&lt;TreePath&gt; checkedPaths = new HashSet&lt;&gt;();
  
      public JCheckboxTree(TreeModel treeModel) {
          super(treeModel);
          // Disabling toggling by double-click
          this.setToggleClickCount(0);
          CheckBoxCellRenderer cellRenderer = new CheckBoxCellRenderer();
          this.setCellRenderer(cellRenderer);
  
          // Overriding selection model by an empty one
          DefaultTreeSelectionModel dtsm = new DefaultTreeSelectionModel() {
              private static final long serialVersionUID = -8190634240451667286L;
  
              // Totally disabling the selection mechanism
              public void setSelectionPath(TreePath path) {
              }
  
              public void addSelectionPath(TreePath path) {
              }
  
              public void removeSelectionPath(TreePath path) {
              }
  
              public void setSelectionPaths(TreePath[] pPaths) {
              }
          };
          // Calling checking mechanism on mouse click
          this.addMouseListener(new MouseListener() {
              public void mouseClicked(MouseEvent arg0) {
                  TreePath tp = selfPointer.getPathForLocation(arg0.getX(), arg0.getY());
                  if (tp == null) {
                      return;
                  }
                  boolean checkMode = !nodesCheckingState.get(tp).isSelected;
                  checkSubTree(tp, checkMode);
                  updatePredecessorsWithCheckMode(tp, checkMode);
                  // Firing the check change event
                  fireCheckChangeEvent(new CheckChangeEvent(new Object()));
                  // Repainting tree after the data structures were updated
                  selfPointer.repaint();
              }
  
              public void mouseEntered(MouseEvent arg0) {
              }
  
              public void mouseExited(MouseEvent arg0) {
              }
  
              public void mousePressed(MouseEvent arg0) {
              }
  
              public void mouseReleased(MouseEvent arg0) {
              }
          });
          this.setSelectionModel(dtsm);
          expandAllNodes(this, 0, this.getRowCount());
      }
  
      public void addCheckChangeEventListener(CheckChangeEventListener listener) {
          listenerList.add(CheckChangeEventListener.class, listener);
      }
  
      public void removeCheckChangeEventListener(CheckChangeEventListener listener) {
          listenerList.remove(CheckChangeEventListener.class, listener);
      }
  
      void fireCheckChangeEvent(CheckChangeEvent evt) {
          Object[] listeners = listenerList.getListenerList();
          for (int i = 0; i &lt; listeners.length; i++) {
              if (listeners[i] == CheckChangeEventListener.class) {
                  ((CheckChangeEventListener) listeners[i + 1]).checkStateChanged(evt);
              }
          }
      }
  
      // Override
      public void setModel(TreeModel newModel) {
          super.setModel(newModel);
          resetCheckingState();
      }
  
      // New method that returns only the checked paths (totally ignores original &quot;selection&quot; mechanism)
      public TreePath[] getCheckedPaths() {
          return checkedPaths.toArray(new TreePath[checkedPaths.size()]);
      }
  
      // Returns true in case that the node is selected, has children but not all of them are selected
      public boolean isSelectedPartially(TreePath path) {
          CheckedNode cn = nodesCheckingState.get(path);
          return cn.isSelected &amp;&amp; cn.hasChildren &amp;&amp; !cn.allChildrenSelected;
      }
  
      private void expandAllNodes(JTree tree, int startingIndex, int rowCount){
          for(int i=startingIndex;i&lt;rowCount;++i){
              tree.expandRow(i);
          }
  
          if(tree.getRowCount()!=rowCount){
              expandAllNodes(tree, rowCount, tree.getRowCount());
          }
      }
  
      private void resetCheckingState() {
          nodesCheckingState = new HashMap&lt;TreePath, CheckedNode&gt;();
          checkedPaths = new HashSet&lt;TreePath&gt;();
          DefaultMutableTreeNode node = (DefaultMutableTreeNode) getModel().getRoot();
          if (node == null) {
              return;
          }
          addSubtreeToCheckingStateTracking(node);
      }
  
      // Creating data structure of the current model for the checking mechanism
      private void addSubtreeToCheckingStateTracking(DefaultMutableTreeNode node) {
          TreeNode[] path = node.getPath();
          TreePath tp = new TreePath(path);
          CheckedNode cn = new CheckedNode(false, node.getChildCount() &gt; 0, false);
          nodesCheckingState.put(tp, cn);
          for (int i = 0; i &lt; node.getChildCount(); i++) {
              addSubtreeToCheckingStateTracking((DefaultMutableTreeNode) tp.pathByAddingChild(node.getChildAt(i)).getLastPathComponent());
          }
      }
  
      // When a node is checked/unchecked, updating the states of the predecessors
      protected void updatePredecessorsWithCheckMode(TreePath tp, boolean check) {
          TreePath parentPath = tp.getParentPath();
          // If it is the root, stop the recursive calls and return
          if (parentPath == null) {
              return;
          }
          CheckedNode parentCheckedNode = nodesCheckingState.get(parentPath);
          DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode) parentPath.getLastPathComponent();
          parentCheckedNode.allChildrenSelected = true;
          parentCheckedNode.isSelected = false;
          for (int i = 0; i &lt; parentNode.getChildCount(); i++) {
              TreePath childPath = parentPath.pathByAddingChild(parentNode.getChildAt(i));
              CheckedNode childCheckedNode = nodesCheckingState.get(childPath);
              // It is enough that even one subtree is not fully selected
              // to determine that the parent is not fully selected
              if (!childCheckedNode.allChildrenSelected) {
                  parentCheckedNode.allChildrenSelected = false;
              }
              // If at least one child is selected, selecting also the parent
              if (childCheckedNode.isSelected) {
                  parentCheckedNode.isSelected = true;
              }
          }
          if (parentCheckedNode.isSelected) {
              checkedPaths.add(parentPath);
          } else {
              checkedPaths.remove(parentPath);
          }
          // Go to upper predecessor
          updatePredecessorsWithCheckMode(parentPath, check);
      }
  
      // Recursively checks/unchecks a subtree
      protected void checkSubTree(TreePath tp, boolean check) {
          CheckedNode cn = nodesCheckingState.get(tp);
          cn.isSelected = check;
          DefaultMutableTreeNode node = (DefaultMutableTreeNode) tp.getLastPathComponent();
          for (int i = 0; i &lt; node.getChildCount(); i++) {
              checkSubTree(tp.pathByAddingChild(node.getChildAt(i)), check);
          }
          cn.allChildrenSelected = check;
          if (check) {
              checkedPaths.add(tp);
          } else {
              checkedPaths.remove(tp);
          }
      }
  
      public interface CheckChangeEventListener extends EventListener {
          void checkStateChanged(CheckChangeEvent event);
      }
  
      // Defining data structure that will enable to fast check-indicate the state of each node
      // It totally replaces the &quot;selection&quot; mechanism of the JTree
      private class CheckedNode {
          boolean isSelected;
          boolean hasChildren;
          boolean allChildrenSelected;
  
          public CheckedNode(boolean isSelected_, boolean hasChildren_, boolean allChildrenSelected_) {
              isSelected = isSelected_;
              hasChildren = hasChildren_;
              allChildrenSelected = allChildrenSelected_;
          }
      }
  
      public class CheckChangeEvent extends EventObject {
          private static final long serialVersionUID = -8100230309044193368L;
  
          public CheckChangeEvent(Object source) {
              super(source);
          }
      }
  
      // Overriding cell renderer by a class that ignores the original &quot;selection&quot; mechanism
      // It decides how to show the nodes due to the checking-mechanism
      private class CheckBoxCellRenderer extends JPanel implements TreeCellRenderer {
          private static final long serialVersionUID = -7341833835878991719L;
          JCheckBox checkBox;
  
          public CheckBoxCellRenderer() {
              super();
              this.setLayout(new BorderLayout());
              checkBox = new JCheckBox();
              checkBox.setSize(new Dimension(100, 100));
              add(checkBox, BorderLayout.CENTER);
              setOpaque(false);
          }
  
          @Override
          public Component getTreeCellRendererComponent(JTree tree, Object value,
                                                        boolean selected, boolean expanded, boolean leaf, int row,
                                                        boolean hasFocus) {
              DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
              Object obj = node.getUserObject();
              TreePath tp = new TreePath(node.getPath());
              CheckedNode cn = nodesCheckingState.get(tp);
              if (cn == null) {
                  return this;
              }
              checkBox.setSelected(cn.isSelected);
              checkBox.setText(obj.toString());
              checkBox.setOpaque(cn.isSelected &amp;&amp; cn.hasChildren &amp;&amp; !cn.allChildrenSelected);
              return this;
          }
      }
  
  }
  </code></pre>