public JsonTreeTableView(TreeNode rootNode, ColumnInfo[] columnInfos) {
    super(new ListTreeTableModelOnColumns(rootNode, columnInfos));
    this.columns = columnInfos;

    final TreeTableTree tree = getTree();

    tree.setShowsRootHandles(true);
    tree.setRootVisible(false);
    UIUtil.setLineStyleAngled(tree);
    setTreeCellRenderer(new KeyCellRenderer());

    TreeUtil.expand(tree, 2);

    new TreeTableSpeedSearch(this, new Convertor<TreePath, String>() {
        @Override
        public String convert(final TreePath path) {
            final NoSqlTreeNode node = (NoSqlTreeNode) path.getLastPathComponent();
            NodeDescriptor descriptor = node.getDescriptor();
            return descriptor.getFormattedKey();
        }
    });
}
 

public void addWatchExpression(@Nullable XStackFrame stackFrame,
                               @Nonnull XExpression expression,
                               int index,
                               boolean navigateToWatchNode) {
  WatchNodeImpl message = new WatchNodeImpl(myTree, this, expression, stackFrame);
  if (index == -1) {
    myChildren.add(message);
    index = myChildren.size() - 1;
  }
  else {
    myChildren.add(index, message);
  }
  fireNodeInserted(index);
  TreeUtil.selectNode(myTree, message);
  if (navigateToWatchNode) {
    myTree.scrollPathToVisible(message.getPath());
  }
}
 

public void addKey(String key, Object value) {

        List<TreeNode> node = new LinkedList<TreeNode>();
        NoSqlTreeNode treeNode = new NoSqlTreeNode(MongoKeyValueDescriptor.createDescriptor(key, value));

        if (value instanceof DBObject) {
            JsonTreeModel.processDbObject(treeNode, (DBObject) value);
        }

        node.add(treeNode);

        DefaultTreeModel treeModel = (DefaultTreeModel) editTableView.getTree().getModel();
        NoSqlTreeNode parentNode = getParentNode();
        if (parentNode == null) {
            parentNode = (NoSqlTreeNode) treeModel.getRoot();
        }
        TreeUtil.addChildrenTo(parentNode, node);
        treeModel.reload(parentNode);
    }
 

@RequiredUIAccess
@Override
public void actionPerformed(final AnActionEvent e) {
  TreeNode defaults = TreeUtil.findNodeWithObject(DEFAULTS, myTree.getModel(), myRoot);
  if (defaults != null) {
    final ConfigurationType configurationType = getSelectedConfigurationType();
    if (configurationType != null) {
      defaults = TreeUtil.findNodeWithObject(configurationType, myTree.getModel(), defaults);
    }
    final DefaultMutableTreeNode defaultsNode = (DefaultMutableTreeNode)defaults;
    if (defaultsNode == null) {
      return;
    }
    final TreePath path = TreeUtil.getPath(myRoot, defaultsNode);
    myTree.expandPath(path);
    TreeUtil.selectInTree(defaultsNode, true, myTree);
    myTree.scrollPathToVisible(path);
  }
}
 

@Override
protected boolean processKeyBinding(KeyStroke ks, KeyEvent e, int condition, boolean pressed) {
  if (e.getKeyCode() == KeyEvent.VK_ENTER && e.getModifiers() == 0 && pressed) {
    if (myTree.isEditing()) {
      myTree.stopEditing();
    }
    else {
      DefaultMutableTreeNode node = (DefaultMutableTreeNode)myTree.getLastSelectedPathComponent();
      if (node != null) {
        myTree.startEditingAtPath(TreeUtil.getPathFromRoot(node));
      }
    }
    return true;
  }
  if (myAllowSyncStrategy && e.getKeyCode() == KeyEvent.VK_F2 && e.getModifiers() == InputEvent.ALT_MASK && pressed) {
    startSyncEditing();
    return true;
  }
  return super.processKeyBinding(ks, e, condition, pressed);
}
 

private static void sortSubTree(final DefaultMutableTreeNode root) {
  TreeUtil.sort(root, new Comparator() {
    @Override
    public int compare(final Object o1, final Object o2) {
      DefaultMutableTreeNode node1 = (DefaultMutableTreeNode)o1;
      DefaultMutableTreeNode node2 = (DefaultMutableTreeNode)o2;
      if (!(node1.getUserObject() instanceof MyUserObject)){
        return 1;
      }
      else if (!(node2.getUserObject() instanceof MyUserObject)){
        return -1;
      }
      return (node1.getUserObject().toString().compareToIgnoreCase(node2.getUserObject().toString()));
    }
  });
}
 

private void applyConfiguration(DefaultMutableTreeNode typeNode, SingleConfigurationConfigurable<?> configurable) throws ConfigurationException {
  try {
    if (configurable != null) {
      configurable.apply();
      RunManagerImpl.getInstanceImpl(myProject).fireRunConfigurationChanged(configurable.getSettings());
    }
  }
  catch (ConfigurationException e) {
    for (int i = 0; i < typeNode.getChildCount(); i++) {
      final DefaultMutableTreeNode node = (DefaultMutableTreeNode)typeNode.getChildAt(i);
      if (Comparing.equal(configurable, node.getUserObject())) {
        TreeUtil.selectNode(myTree, node);
        break;
      }
    }
    throw e;
  }
}
 

@Nonnull
private Promise<TreePath> rebuildAndSelect(boolean refilterOnly, Object selection) {
  AsyncPromise<TreePath> result = new AsyncPromise<>();
  myStructureTreeModel.getInvoker().runOrInvokeLater(() -> {
    if (refilterOnly) {
      myFilteringStructure.refilter();
      myStructureTreeModel.invalidate().onSuccess(
              res -> (selection == null ? myAsyncTreeModel.accept(o -> TreeVisitor.Action.CONTINUE) : select(selection)).onError(ignore2 -> result.setError("rejected")).onSuccess(p -> UIUtil.invokeLaterIfNeeded(() -> {
                TreeUtil.expand(getTree(), myTreeModel instanceof StructureViewCompositeModel ? 3 : 2);
                TreeUtil.ensureSelection(myTree);
                mySpeedSearch.refreshSelection();
                result.setResult(p);
              })));
    }
    else {
      myTreeStructure.rebuildTree();
      myStructureTreeModel.invalidate().onSuccess(res -> rebuildAndSelect(true, selection).processed(result));
    }
  });
  return result;
}
 

@Override
public void treeNodesInserted(TreeModelEvent e) {
  TreePath parentPath = e.getTreePath();
  if (Boolean.TRUE.equals(UIUtil.getClientProperty(tree, STRUCTURE_VIEW_STATE_RESTORED_KEY))) return;
  if (parentPath == null || parentPath.getPathCount() > autoExpandDepth.asInteger() - 1) return;
  Object[] children = e.getChildren();
  if (smartExpand && children.length == 1) {
    expandLater(parentPath, children[0]);
  }
  else {
    for (Object o : children) {
      NodeDescriptor descriptor = TreeUtil.getUserObject(NodeDescriptor.class, o);
      if (descriptor != null && isAutoExpandNode(descriptor)) {
        expandLater(parentPath, o);
      }
    }
  }
}
 

private int findRowContainingFile(@Nonnull TreeNode root, @Nonnull final VirtualFile toSelect) {
  final Ref<Integer> row = Ref.create(-1);
  TreeUtil.traverse(root, node -> {
    if (node instanceof DefaultMutableTreeNode) {
      Object userObject = ((DefaultMutableTreeNode)node).getUserObject();
      if (userObject instanceof Change) {
        if (matches((Change)userObject, toSelect)) {
          TreeNode[] path = ((DefaultMutableTreeNode)node).getPath();
          row.set(getRowForPath(new TreePath(path)));
        }
      }
    }

    return row.get() == -1;
  });
  return row.get();
}
 

public void buildTree(@Nonnull Collection<? extends BreakpointItem> breakpoints) {
  final TreeState state = TreeState.createOn(myTreeView, myRoot);
  myRoot.removeAllChildren();
  myNodes.clear();
  for (BreakpointItem breakpoint : breakpoints) {
    BreakpointItemNode node = new BreakpointItemNode(breakpoint);
    CheckedTreeNode parent = getParentNode(breakpoint);
    parent.add(node);
    myNodes.put(breakpoint, node);
  }
  TreeUtil.sortRecursively(myRoot, COMPARATOR);
  myInBuild = true;
  ((DefaultTreeModel)(myTreeView.getModel())).nodeStructureChanged(myRoot);
  state.applyTo(myTreeView, myRoot);
  myInBuild = false;
}
 

protected void clearChildren() {
  TreeUtil.traverseDepth(myRoot, new TreeUtil.Traverse() {
    @Override
    public boolean accept(Object node) {
      if (node instanceof MyNode) {
        final MyNode treeNode = ((MyNode)node);
        treeNode.getConfigurable().disposeUIResources();
        if (!(treeNode instanceof MyRootNode)) {
          treeNode.setUserObject(null);
        }
      }
      return true;
    }
  });
  myRoot.removeAllChildren();
}
 

private void reloadTree() {
  myRoot.removeAllChildren();
  loadScopes(mySharedScopesManager);
  loadScopes(myLocalScopesManager);

  if (isModified()) {
    loadStateOrder();
  }


  final List<String> order = getScopesState().myOrder;
  TreeUtil.sort(myRoot, new Comparator<DefaultMutableTreeNode>() {
    @Override
    public int compare(final DefaultMutableTreeNode o1, final DefaultMutableTreeNode o2) {
      final int idx1 = order.indexOf(((MyNode)o1).getDisplayName());
      final int idx2 = order.indexOf(((MyNode)o2).getDisplayName());
      return idx1 - idx2;
    }
  });
}
 

public void reset() {
  List<ToolsGroup<T>> groups = getToolsGroups();

  for (ToolsGroup group : groups) {
    insertNewGroup((ToolsGroup)group.copy());
  }

  if ((getTreeRoot()).getChildCount() > 0) {
    myTree.setSelectionInterval(0, 0);
  }
  else {
    myTree.getSelectionModel().clearSelection();
  }
  (getModel()).nodeStructureChanged(null);

  TreeUtil.expand(myTree, 5);

  myIsModified = false;

  update();
}
 

@RequiredUIAccess
@Override
public void update(AnActionEvent e) {
  boolean isEnabled = TreeUtil.findNodeWithObject(DEFAULTS, myTree.getModel(), myRoot) != null;
  TreePath path = myTree.getSelectionPath();
  if (path != null) {
    Object o = path.getLastPathComponent();
    if (o instanceof DefaultMutableTreeNode && ((DefaultMutableTreeNode)o).getUserObject().equals(DEFAULTS)) {
      isEnabled = false;
    }
    o = path.getParentPath().getLastPathComponent();
    if (o instanceof DefaultMutableTreeNode && ((DefaultMutableTreeNode)o).getUserObject().equals(DEFAULTS)) {
      isEnabled = false;
    }
  }
  e.getPresentation().setEnabled(isEnabled);
}
 

@Nonnull
private Runnable wrapScrollTo(Runnable onDone, @Nonnull Object element, @Nonnull DefaultMutableTreeNode node, boolean addToSelection, boolean canBeCentered, boolean scroll) {
  return new TreeRunnable("AbstractTreeUi.wrapScrollTo") {
    @Override
    public void perform() {
      int row = getRowIfUnderSelection(element);
      if (row == -1) row = myTree.getRowForPath(new TreePath(node.getPath()));
      int top = row - 2;
      int bottom = row + 2;
      if (canBeCentered && Registry.is("ide.tree.autoscrollToVCenter")) {
        int count = TreeUtil.getVisibleRowCount(myTree) - 1;
        top = count > 0 ? row - count / 2 : row;
        bottom = count > 0 ? top + count : row;
      }
      TreeUtil.showAndSelect(myTree, top, bottom, row, -1, addToSelection, scroll).doWhenDone(wrapDone(onDone, "AbstractTreeUi.wrapScrollTo.onDone"));
    }
  };
}
 

private TreePath removeNode(DefaultMutableTreeNode node) {
  DefaultMutableTreeNode parent = (DefaultMutableTreeNode)node.getParent();
  if (parent != null) {
    IndexTreePathState state = new IndexTreePathState(TreeUtil.getPathFromRoot(node));
    removeNodeFromParent(node);
    if (parent.isLeaf()) {
      return removeNode(parent);
    }
    return state.getRestoredPath();
  }
  return null;
}
 

private void filterTreeByShortcut(final ShortcutTextField firstShortcut, final JCheckBox enable2Shortcut, final ShortcutTextField secondShortcut) {
  final KeyStroke keyStroke = firstShortcut.getKeyStroke();
  if (keyStroke != null) {
    if (!myTreeExpansionMonitor.isFreeze()) myTreeExpansionMonitor.freeze();
    myActionsTree.filterTree(new KeyboardShortcut(keyStroke, enable2Shortcut.isSelected() ? secondShortcut.getKeyStroke() : null), getCurrentQuickListIds());
    final JTree tree = myActionsTree.getTree();
    TreeUtil.expandAll(tree);
  }
}
 

private void sortChildren(InspectionTreeNode node) {
  final List<TreeNode> children = TreeUtil.listChildren(node);
  Collections.sort(children, InspectionResultsViewComparator.getInstance());
  node.removeAllChildren();
  TreeUtil.addChildrenTo(node, children);
  ((DefaultTreeModel)getModel()).reload(node);
}
 

private void selectTemplate(final String lastSelectedGroup, final String lastSelectedKey) {
  TreeUtil.traverseDepth(myTreeRoot, new TreeUtil.Traverse() {
    @Override
    public boolean accept(Object node) {
      Object o = ((DefaultMutableTreeNode)node).getUserObject();
      if (lastSelectedKey == null && o instanceof TemplateGroup && Comparing.equal(lastSelectedGroup, ((TemplateGroup)o).getName()) ||
          o instanceof TemplateImpl && Comparing.equal(lastSelectedKey, ((TemplateImpl)o).getKey()) && Comparing.equal(lastSelectedGroup, ((TemplateImpl)o).getGroupName())) {
        setSelectedNode((DefaultMutableTreeNode)node);
        return false;
      }

      return true;
    }
  });
}
 

public void selectIntention(String familyName) {
  final CheckedTreeNode child = findChildRecursively(getRoot(), familyName);
  if (child != null) {
    final TreePath path = new TreePath(child.getPath());
    TreeUtil.selectPath(myTree, path);
  }
}
 

int getFilteredFilesCount() {
  Pair<PackageSetBase, NamedScopesHolder> scopeFilter = getScopeFilter();
  int[] result = new int[1];
  TreeUtil.traverse(myRoot, node -> {
    if (node instanceof FileTreeNode) {
      if (((FileTreeNode)node).acceptFilter(scopeFilter, true)) {
        result[0]++;
      }
    }
    return true;
  });
  return result[0];
}
 

@Override
public void centerSelectedRow() {
  TreePath path = getTree().getSelectionPath();
  if (path == null) return;

  myAutoScrollToSourceHandler.setShouldAutoScroll(false);
  TreeUtil.showRowCentered(getTree(), getTree().getRowForPath(path), false);
  myAutoScrollToSourceHandler.setShouldAutoScroll(true);
}
 

private static ActionGroup createTreePopupActions(final boolean isRightTree, final Tree tree) {
  DefaultActionGroup group = new DefaultActionGroup();
  final TreeExpander treeExpander = new TreeExpander() {
    @Override
    public void expandAll() {
      TreeUtil.expandAll(tree);
    }

    @Override
    public boolean canExpand() {
      return isRightTree;
    }

    @Override
    public void collapseAll() {
      TreeUtil.collapseAll(tree, 3);
    }

    @Override
    public boolean canCollapse() {
      return true;
    }
  };

  final CommonActionsManager actionManager = CommonActionsManager.getInstance();
  if (isRightTree){
    group.add(actionManager.createExpandAllAction(treeExpander, tree));
  }
  group.add(actionManager.createCollapseAllAction(treeExpander, tree));
  final ActionManager globalActionManager = ActionManager.getInstance();
  group.add(globalActionManager.getAction(IdeActions.ACTION_EDIT_SOURCE));
  group.add(AnSeparator.getInstance());
  group.add(globalActionManager.getAction(IdeActions.ACTION_ANALYZE_DEPENDENCIES));
  group.add(globalActionManager.getAction(IdeActions.ACTION_ANALYZE_BACK_DEPENDENCIES));
  //non exists in platform group.add(globalActionManager.getAction(IdeActions.ACTION_ANALYZE_CYCLIC_DEPENDENCIES));
  return group;
}
 

@Override
public JScrollPane createScrollPane() {
  TreeUtil.expandAll(myTree);

  JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(myTree);

  scrollPane.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));

  if (myTree.getSelectionCount() == 0) {
    myTree.setSelectionRow(0);
  }

  if (myTree.getRowCount() >= 20) {
    scrollPane.getViewport().setPreferredSize(new Dimension(myTree.getPreferredScrollableViewportSize().width, 300));
  }
  else {
    scrollPane.getViewport().setPreferredSize(myTree.getPreferredSize());
  }

  if (myBuilder.isAutoselectOnMouseMove()) {
    myTree.addMouseMotionListener(new MouseMotionAdapter() {
      boolean myIsEngaged = false;

      @Override
      public void mouseMoved(MouseEvent e) {
        if (myIsEngaged) {
          final Point p = e.getPoint();
          int index = myTree.getRowForLocation(p.x, p.y);
          myTree.setSelectionRow(index);
        }
        else {
          myIsEngaged = true;
        }
      }
    });
  }

  return scrollPane;
}
 

public void show() {
  JComponent panel = createCenterPanel();
  MnemonicHelper.init(panel);
  myTree.addTreeSelectionListener(__ -> {
    if (myPopup.isVisible()) {
      PopupUpdateProcessor updateProcessor = myPopup.getUserData(PopupUpdateProcessor.class);
      if (updateProcessor != null) {
        AbstractTreeNode node = getSelectedNode();
        updateProcessor.updatePopup(node);
      }
    }
  });

  myPopup = JBPopupFactory.getInstance().createComponentPopupBuilder(panel, myTree).setTitle(myTitle).setResizable(true).setModalContext(false).setFocusable(true).setRequestFocus(true)
          .setMovable(true).setBelongsToGlobalPopupStack(true)
          //.setCancelOnClickOutside(false) //for debug and snapshots
          .setCancelOnOtherWindowOpen(true).setCancelKeyEnabled(false).setDimensionServiceKey(null, getDimensionServiceKey(), true).setCancelCallback(() -> myCanClose).setNormalWindowLevel(true)
          .createPopup();

  Disposer.register(myPopup, this);
  Disposer.register(myPopup, () -> {
    if (!myTreeHasBuilt.isDone()) {
      myTreeHasBuilt.setRejected();
    }
  });
  myTree.getEmptyText().setText("Loading...");
  myPopup.showCenteredInCurrentWindow(myProject);

  ((AbstractPopup)myPopup).setShowHints(true);

  IdeFocusManager.getInstance(myProject).requestFocus(myTree, true);

  rebuildAndSelect(false, myInitialElement).onProcessed(path -> UIUtil.invokeLaterIfNeeded(() -> {
    TreeUtil.ensureSelection(myTree);
    myTreeHasBuilt.setDone();
    installUpdater();
  }));
}
 

@Test
public void copyMongoResults() throws Exception {
    mongoResultPanel.updateResultTableTree(createCollectionResults("arrayOfDocuments.json", "mycollec"));

    TreeUtil.expandAll(mongoResultPanel.resultTableView.getTree());

    frameFixture.table("resultTreeTable").cellReader(new TableCellReader())
            .requireContents(new String[][]{
                    {"[0]", "{ \"id\" : 0 , \"label\" : \"toto\" , \"visible\" : false , \"doc\" : { \"title\" : \"hello\" , \"nbPages\" : 10 , \"keyWord\" : [ \"toto\" , true , 10]}}"},
                    {"id", "0"},
                    {"label", "\"toto\""},
                    {"visible", "false"},
                    {"doc", "{ \"title\" : \"hello\" , \"nbPages\" : 10 , \"keyWord\" : [ \"toto\" , true , 10]}"},
                    {"title", "\"hello\""},
                    {"nbPages", "10"},
                    {"keyWord", "[ \"toto\" , true , 10]"},
                    {"[0]", "\"toto\""},
                    {"[1]", "true"},
                    {"[2]", "10"},
                    {"[1]", "{ \"id\" : 1 , \"label\" : \"tata\" , \"visible\" : true , \"doc\" : { \"title\" : \"ola\" , \"nbPages\" : 1 , \"keyWord\" : [ \"tutu\" , false , 10]}}"},
                    {"id", "1"},
                    {"label", "\"tata\""},
                    {"visible", "true"},
                    {"doc", "{ \"title\" : \"ola\" , \"nbPages\" : 1 , \"keyWord\" : [ \"tutu\" , false , 10]}"},
                    {"title", "\"ola\""},
                    {"nbPages", "1"},
                    {"keyWord", "[ \"tutu\" , false , 10]"},
                    {"[0]", "\"tutu\""},
                    {"[1]", "false"},
                    {"[2]", "10"},
            });

    assertEquals("[ " +
            "{ \"id\" : 0 , \"label\" : \"toto\" , \"visible\" : false , \"doc\" : { \"title\" : \"hello\" , \"nbPages\" : 10 , \"keyWord\" : [ \"toto\" , true , 10]}} , " +
            "{ \"id\" : 1 , \"label\" : \"tata\" , \"visible\" : true , \"doc\" : { \"title\" : \"ola\" , \"nbPages\" : 1 , \"keyWord\" : [ \"tutu\" , false , 10]}}" +
            " ]",
            mongoResultPanel.getSelectedNodeStringifiedValue());
}
 

@Nonnull
public static SelectionInfo create(final AbstractProjectViewPane viewPane) {
  List<Object> selectedElements = Collections.emptyList();
  if (viewPane != null) {
    final TreePath[] selectionPaths = viewPane.getSelectionPaths();
    if (selectionPaths != null) {
      selectedElements = new ArrayList<>();
      for (TreePath path : selectionPaths) {
        NodeDescriptor descriptor = TreeUtil.getLastUserObject(NodeDescriptor.class, path);
        if (descriptor != null) selectedElements.add(descriptor.getElement());
      }
    }
  }
  return new SelectionInfo(selectedElements.toArray());
}
 

@TestOnly
public AsyncPromise<Void> rebuildAndUpdate() {
  AsyncPromise<Void> result = new AsyncPromise<>();
  TreeVisitor visitor = path -> {
    AbstractTreeNode node = TreeUtil.getLastUserObject(AbstractTreeNode.class, path);
    if (node != null) node.update();
    return TreeVisitor.Action.CONTINUE;
  };
  rebuild(false).onProcessed(ignore1 -> myAsyncTreeModel.accept(visitor).onProcessed(ignore2 -> result.setResult(null)));
  return result;
}
 

private void filterTree(@Nullable String filter) {
  if (myTreeTable != null) {
    getExpandedNodes(mySelectedProfile).saveVisibleState(myTreeTable.getTree());
    fillTreeData(filter, true);
    reloadModel();
    restoreTreeState();
    if (myTreeTable.getTree().getSelectionPath() == null) {
      TreeUtil.selectFirstNode(myTreeTable.getTree());
    }
  }
}