Java Code Examples for com.intellij.util.ui.tree.TreeUtil#selectNode()

@javax.annotation.Nullable
private DefaultMutableTreeNode getFirstNodeToEdit() {
  // start edit last selected component if editable
  if (myTree.getLastSelectedPathComponent() instanceof RepositoryNode) {
    RepositoryNode selectedNode = ((RepositoryNode)myTree.getLastSelectedPathComponent());
    if (selectedNode.isEditableNow()) return selectedNode;
  }
  List<RepositoryNode> repositoryNodes = getChildNodesByType((DefaultMutableTreeNode)myTree.getModel().getRoot(),
                                                             RepositoryNode.class, false);
  RepositoryNode editableNode = ContainerUtil.find(repositoryNodes, new Condition<RepositoryNode>() {
    @Override
    public boolean value(RepositoryNode repositoryNode) {
      return repositoryNode.isEditableNow();
    }
  });
  if (editableNode != null) {
    TreeUtil.selectNode(myTree, editableNode);
  }
  return editableNode;
}
 

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 activateView(final ShelvedChangeList list) {
  Runnable runnable = new Runnable() {
    @Override
    public void run() {
      if (list != null) {
        TreeUtil.selectNode(myTree, TreeUtil.findNodeWithObject(myRoot, list));
      }
      myContentManager.setSelectedContent(myContent);
      ToolWindow window = ToolWindowManager.getInstance(myProject).getToolWindow(ChangesViewContentManager.TOOLWINDOW_ID);
      if (!window.isVisible()) {
        window.activate(null);
      }
    }
  };
  if (myUpdatePending) {
    myPostUpdateRunnable = runnable;
  }
  else {
    runnable.run();
  }
}
 

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;
  }
}
 

public void selectBreakpointItem(@Nullable final BreakpointItem breakpoint, TreePath path) {
  BreakpointItemNode node = myNodes.get(breakpoint);
  if (node != null) {
    TreeUtil.selectNode(myTreeView, node);
  }
  else {
    TreeUtil.selectPath(myTreeView, path);
  }
}
 

@Override
public void cancelEditing() {
  if (!isShown()) return;
  super.cancelEditing();
  int index = myRootNode.getIndex(myNode);
  if (myOldNode == null && index != -1) {
    myRootNode.removeChildNode(myNode);
  }
  TreeUtil.selectNode(myTree, myNode);
}
 

@Override
public void doOKAction() {
  XExpression expression = getExpression();
  super.doOKAction();
  int index = myRootNode.removeChildNode(myNode);
  if (!XDebuggerUtilImpl.isEmptyExpression(expression) && index != -1) {
    myWatchesView.addWatchExpression(expression, index, false);
  }
  TreeUtil.selectNode(myTree, myNode);
}
 

@Override
public void selectFile(@Nullable VirtualFile vFile) {
  if (vFile == null) return;
  Change change = ChangeListManager.getInstance(myProject).getChange(vFile);
  Object objectToFind = change != null ? change : vFile;

  DefaultMutableTreeNode root = (DefaultMutableTreeNode)myView.getModel().getRoot();
  DefaultMutableTreeNode node = TreeUtil.findNodeWithObject(root, objectToFind);
  if (node != null) {
    TreeUtil.selectNode(myView, node);
  }
}
 

public void updateSelection() {
  if (myTreeTable != null) {
    final TreePath selectionPath = myTreeTable.getTree().getSelectionPath();
    if (selectionPath != null) {
      TreeUtil.selectNode(myTreeTable.getTree(), (TreeNode) selectionPath.getLastPathComponent());
      final int rowForPath = myTreeTable.getTree().getRowForPath(selectionPath);
      TableUtil.selectRows(myTreeTable, new int[]{rowForPath});
      scrollToCenter();
    }
  }
}
 

public void selectInspectionTool(String name) {
  final InspectionConfigTreeNode node = findNodeByKey(name, myRoot);
  if (node != null) {
    TreeUtil.selectNode(myTreeTable.getTree(), node);
    final int rowForPath = myTreeTable.getTree().getRowForPath(new TreePath(node.getPath()));
    TableUtil.selectRows(myTreeTable, new int[]{rowForPath});
    scrollToCenter();
  }
}
 

private SingleConfigurationConfigurable<RunConfiguration> createNewConfiguration(final RunnerAndConfigurationSettings settings, final DefaultMutableTreeNode node) {
  final SingleConfigurationConfigurable<RunConfiguration> configurationConfigurable =
          SingleConfigurationConfigurable.editSettings(settings, null);
  installUpdateListeners(configurationConfigurable);
  DefaultMutableTreeNode nodeToAdd = new DefaultMutableTreeNode(configurationConfigurable);
  myTreeModel.insertNodeInto(nodeToAdd, node, node.getChildCount());
  TreeUtil.selectNode(myTree, nodeToAdd);
  return configurationConfigurable;
}
 

@Override
public void selectTemplate(FileTemplate template) {
  String name = template.getName();
  if (template.getExtension().length() > 0) {
    name += "." + template.getExtension();
  }

  final FileTemplateNode node = (FileTemplateNode)TreeUtil.findNodeWithObject(myRoot, name);
  if (node != null) {
    TreeUtil.selectNode(myTree, node);
    onTemplateSelected(); // this is important because we select different Template for the same node
  }
}
 

private void restoreSelection(@javax.annotation.Nullable DefaultMutableTreeNode node) {
  if (node != null) {
    TreeUtil.selectNode(myTree, node);
  }
}