docs: @Override
      public void setActive(boolean active) {
          TreeModelEvent event = null;
          BugTreeModel.TreeModification whatToDo;
  
          if (active != this.active) {
              if (active == false) {
                  this.active = active;
              }
  
              StackedFilterMatcher theSame = this;
              FilterMatcher[] filtersInStack = theSame.getFilters();
              ArrayList<Sortables> order = MainFrame.getInstance().getSorter().getOrder();
              int sizeToCheck = filtersInStack.length;
              if (order.contains(Sortables.DIVIDER)) {
                  if (order.indexOf(Sortables.DIVIDER) < filtersInStack.length) {
                      sizeToCheck++;
                  }
              }
              List<Sortables> sortablesToCheck = order.subList(0, Math.min(sizeToCheck, order.size()));
              Debug.println("Size to check" + sizeToCheck + " checking list" + sortablesToCheck);
              Debug.println("checking filters");
              ArrayList<String> almostPath = new ArrayList<>();
              ArrayList<Sortables> almostPathSortables = new ArrayList<>();
              for (int x = 0; x < sortablesToCheck.size(); x++) {
                  Sortables s = sortablesToCheck.get(x);
                  for (FilterMatcher fm : filtersInStack) {
                      if (s.equals(fm.getFilterBy())) {
                          almostPath.add(fm.getValue());
                          almostPathSortables.add(fm.getFilterBy());
                      }
                  }
              }
              ArrayList<String> finalPath = new ArrayList<>();
              for (int x = 0; x < almostPath.size(); x++) {
                  Sortables s = almostPathSortables.get(x);
                  if (MainFrame.getInstance().getSorter().getOrderBeforeDivider().contains(s)) {
                      finalPath.add(almostPath.get(x));
                  }
              }
              try {
                  if (finalPath.size() == filtersInStack.length) {
                      if (active == true) {
                          event = (MainFrame.getInstance().getBugTreeModel()).removeBranch(finalPath);
                          whatToDo = BugTreeModel.TreeModification.REMOVE;
                      } else {
                          event = (MainFrame.getInstance().getBugTreeModel()).insertBranch(finalPath);
                          whatToDo = BugTreeModel.TreeModification.INSERT;
                      }
                  } else {
                      event = (MainFrame.getInstance().getBugTreeModel()).restructureBranch(finalPath, active);// if
                      // active
                      // is
                      // true,
                      // this
                      // removes,
                      // if
                      // active
                      // if
                      // false,
                      // it
                      // inserts
                      if (active) {
                          whatToDo = BugTreeModel.TreeModification.REMOVERESTRUCTURE;
                      } else {
                          whatToDo = BugTreeModel.TreeModification.INSERTRESTRUCTURE;
                      }
                  }
  
                  if (active == true) {
                      this.active = active;
                  }
                  (MainFrame.getInstance().getBugTreeModel()).sendEvent(event, whatToDo);
              } catch (BranchOperationException e) {
                  // Another filter already filters out the branch this filter
                  // would filter out, set active, but don't send any tree model
                  // events.
                  this.active = active;
              }
          }
  
      }