Java TreeItem类代码示例

import com.intellij.util.TreeItem; //导入依赖的package包/类
public boolean addRoots(final String name, final Collection<AbstractTreeNode> nodes) {
  final Collection<TreeItem<Pair<AbstractUrl, String>>> list = getFavoritesListRootUrls(name);

  final HashSet<AbstractUrl> set =
    new HashSet<AbstractUrl>(ContainerUtil.map(list, new Function<TreeItem<Pair<AbstractUrl,String>>, AbstractUrl>() {
      @Override
      public AbstractUrl fun(TreeItem<Pair<AbstractUrl, String>> item) {
        return item.getData().getFirst();
      }
    }));
  for (AbstractTreeNode node : nodes) {
    final Pair<AbstractUrl, String> pair = createPairForNode(node);
    if (pair != null) {
      if (set.contains(pair.getFirst())) continue;
      final TreeItem<Pair<AbstractUrl, String>> treeItem = new TreeItem<Pair<AbstractUrl, String>>(pair);
      list.add(treeItem);
      set.add(pair.getFirst());
      appendChildNodes(node, treeItem);
    }
  }
  rootsChanged();
  return true;
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
public boolean canAddRoots(@NotNull String name, @NotNull Collection<AbstractTreeNode> nodes) {
  final Collection<TreeItem<Pair<AbstractUrl, String>>> list = getFavoritesListRootUrls(name);

  final HashSet<AbstractUrl> set =
    new HashSet<AbstractUrl>(ContainerUtil.map(list, new Function<TreeItem<Pair<AbstractUrl,String>>, AbstractUrl>() {
      @Override
      public AbstractUrl fun(TreeItem<Pair<AbstractUrl, String>> item) {
        return item.getData().getFirst();
      }
    }));
  for (AbstractTreeNode node : nodes) {
    final Pair<AbstractUrl, String> pair = createPairForNode(node);
    if (pair != null && !set.contains(pair.getFirst())) return true;
  }
  return false;
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
public List<TreeItem<VcsFileRevision>> createTreeOn(List<VcsFileRevision> allRevisions) {
  Collections.sort(allRevisions, VcsFileRevisionComparator.INSTANCE);

  final List<TreeItem<VcsFileRevision>> result = new ArrayList<TreeItem<VcsFileRevision>>();

  TreeItem<VcsFileRevision> prevRevision = null;
  for (final VcsFileRevision sortedRevision : allRevisions) {
    final CvsFileRevisionImpl cvsFileRevision = (CvsFileRevisionImpl)sortedRevision;
    final TreeItem<VcsFileRevision> treeItem = new TreeItem<VcsFileRevision>(cvsFileRevision);
    final TreeItem<VcsFileRevision> commonParent = getCommonParent(prevRevision, treeItem);
    if (commonParent != null) {
      commonParent.addChild(treeItem);
    }
    else {
      result.add(treeItem);
    }
    prevRevision = treeItem;
  }

  return result;
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
public boolean addRoots(final String name, final Collection<AbstractTreeNode> nodes) {
  final Collection<TreeItem<Pair<AbstractUrl, String>>> list = getFavoritesListRootUrls(name);

  final HashSet<AbstractUrl> set =
    new HashSet<AbstractUrl>(ObjectsConvertor.convert(list, new Convertor<TreeItem<Pair<AbstractUrl, String>>, AbstractUrl>() {
      @Override
      public AbstractUrl convert(TreeItem<Pair<AbstractUrl, String>> o) {
        return o.getData().getFirst();
      }
    }));
  for (AbstractTreeNode node : nodes) {
    final Pair<AbstractUrl, String> pair = createPairForNode(node);
    if (pair != null) {
      if (set.contains(pair.getFirst())) continue;
      final TreeItem<Pair<AbstractUrl, String>> treeItem = new TreeItem<Pair<AbstractUrl, String>>(pair);
      list.add(treeItem);
      set.add(pair.getFirst());
      appendChildNodes(node, treeItem);
    }
  }
  rootsChanged();
  return true;
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
private boolean renameFavoritesList(@NotNull String oldName, @NotNull String newName) {
  List<TreeItem<Pair<AbstractUrl, String>>> list = myName2FavoritesRoots.remove(oldName);
  if (list != null && newName.length() > 0) {
    int index = myListOrder.indexOf(oldName);
    if (index == -1) {
      index = myListOrder.size();
    }
    myListOrder.set(index, newName);
    myName2FavoritesRoots.put(newName, list);
    String description = myDescriptions.remove(oldName);
    if (description != null) {
      myDescriptions.put(newName, description);
    }
    rootsChanged();
    return true;
  }
  return false;
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
public boolean addRoots(final String name, final Collection<AbstractTreeNode> nodes) {
  final Collection<TreeItem<Pair<AbstractUrl, String>>> list = getFavoritesListRootUrls(name);

  final HashSet<AbstractUrl> set = new HashSet<AbstractUrl>(ContainerUtil.map(list, new Function<TreeItem<Pair<AbstractUrl, String>>, AbstractUrl>() {
    @Override
    public AbstractUrl fun(TreeItem<Pair<AbstractUrl, String>> item) {
      return item.getData().getFirst();
    }
  }));
  for (AbstractTreeNode node : nodes) {
    final Pair<AbstractUrl, String> pair = createPairForNode(node);
    if (pair != null) {
      if (set.contains(pair.getFirst())) continue;
      final TreeItem<Pair<AbstractUrl, String>> treeItem = new TreeItem<Pair<AbstractUrl, String>>(pair);
      list.add(treeItem);
      set.add(pair.getFirst());
      appendChildNodes(node, treeItem);
    }
  }
  rootsChanged();
  return true;
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
private boolean renameFavoritesList(@Nonnull String oldName, @Nonnull String newName) {
  List<TreeItem<Pair<AbstractUrl, String>>> list = myName2FavoritesRoots.remove(oldName);
  if (list != null && newName.length() > 0) {
    int index = myListOrder.indexOf(oldName);
    if (index == -1) {
      index = myListOrder.size();
    }
    myListOrder.set(index, newName);
    myName2FavoritesRoots.put(newName, list);
    String description = myDescriptions.remove(oldName);
    if (description != null) {
      myDescriptions.put(newName, description);
    }
    rootsChanged();
    return true;
  }
  return false;
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
private static void showTreePopup(final List<TreeItem<VcsFileRevision>> roots, final VirtualFile file, final Project project, final DiffProvider diffProvider) {
  final TreeTableView treeTable = new TreeTableView(new ListTreeTableModelOnColumns(new TreeNodeAdapter(null, null, roots),
                                                                                    new ColumnInfo[]{BRANCH_COLUMN, REVISION_COLUMN,
                                                                                    DATE_COLUMN, AUTHOR_COLUMN}));
  Runnable runnable = new Runnable() {
    @Override
    public void run() {
      int index = treeTable.getSelectionModel().getMinSelectionIndex();
      if (index == -1) {
        return;
      }
      VcsFileRevision revision = getRevisionAt(treeTable, index);
      if (revision != null) {
        DiffActionExecutor.showDiff(diffProvider, revision.getRevisionNumber(), file, project, VcsBackgroundableActions.COMPARE_WITH);
      }
    }
  };

  treeTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  new PopupChooserBuilder(treeTable).
    setTitle(VcsBundle.message("lookup.title.vcs.file.revisions")).
    setItemChoosenCallback(runnable).
    setSouthComponent(createCommentsPanel(treeTable)).
    setResizable(true).
    setDimensionServiceKey("Vcs.CompareWithSelectedRevision.Popup").
    createPopup().
    showCenteredInCurrentWindow(project);

  final int lastRow = treeTable.getRowCount() - 1;
  if (lastRow < 0) return;
  treeTable.getSelectionModel().addSelectionInterval(lastRow, lastRow);
  treeTable.scrollRectToVisible(treeTable.getCellRect(lastRow, 0, true));
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
public TreeNodeAdapter(TreeNodeAdapter parent, TreeItem<VcsFileRevision> revision, List<TreeItem<VcsFileRevision>> children) {
  if (parent != null) {
    parent.add(this);
  }
  myRevision = revision;
  for (TreeItem<VcsFileRevision> treeItem : children) {
    new TreeNodeAdapter(this, treeItem, treeItem.getChildren());
  }
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
private void appendChildNodes(AbstractTreeNode node, TreeItem<Pair<AbstractUrl, String>> treeItem) {
  final Collection<? extends AbstractTreeNode> children = node.getChildren();
  for (AbstractTreeNode child : children) {
    final TreeItem<Pair<AbstractUrl, String>> childTreeItem = new TreeItem<Pair<AbstractUrl, String>>(createPairForNode(child));
    treeItem.addChild(childTreeItem);
    appendChildNodes(child, childTreeItem);
  }
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
private <T> boolean findListToRemoveFrom(@NotNull String name, @NotNull final List<T> elements,
                                         final Convertor<T, AbstractUrl> convertor) {
  Collection<TreeItem<Pair<AbstractUrl, String>>> list = getFavoritesListRootUrls(name);
  if (elements.size() > 1) {
    final List<T> sublist = elements.subList(0, elements.size() - 1);
    for (T obj : sublist) {
      AbstractUrl objUrl = convertor.convert(obj);
      final TreeItem<Pair<AbstractUrl, String>> item = findNextItem(objUrl, list);
      if (item == null || item.getChildren() == null) return false;
      list = item.getChildren();
    }
  }

  TreeItem<Pair<AbstractUrl, String>> found = null;
  AbstractUrl url = convertor.convert(elements.get(elements.size() - 1));
  if (url == null) return false;
  for (TreeItem<Pair<AbstractUrl, String>> pair : list) {
    if (url.equals(pair.getData().getFirst())) {
      found = pair;
      break;
    }
  }

  if (found != null) {
    list.remove(found);
    rootsChanged();
    return true;
  }
  return false;
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
private TreeItem<Pair<AbstractUrl, String>> findNextItem(AbstractUrl url, Collection<TreeItem<Pair<AbstractUrl, String>>> list) {
  for (TreeItem<Pair<AbstractUrl, String>> pair : list) {
    if (url.equals(pair.getData().getFirst())) {
      return pair;
    }
  }
  return null;
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
private boolean renameFavoritesList(@NotNull String oldName, @NotNull String newName) {
  List<TreeItem<Pair<AbstractUrl, String>>> list = myName2FavoritesRoots.remove(oldName);
  if (list != null && newName.length() > 0) {
    myName2FavoritesRoots.put(newName, list);
    String description = myDescriptions.remove(oldName);
    if (description != null) {
      myDescriptions.put(newName, description);
    }
    rootsChanged();
    return true;
  }
  return false;
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
@Override
public void readExternal(Element element) throws InvalidDataException {
  myName2FavoritesRoots.clear();
  for (Object list : element.getChildren(ELEMENT_FAVORITES_LIST)) {
    final String name = ((Element)list).getAttributeValue(ATTRIBUTE_NAME);
    List<TreeItem<Pair<AbstractUrl, String>>> roots = readRoots((Element)list, myProject);
    myName2FavoritesRoots.put(name, roots);
  }
  DefaultJDOMExternalizer.readExternal(this, element);
}
 

import com.intellij.util.TreeItem; //导入依赖的package包/类
private static void readFavoritesOneLevel(Element list, Project project, Collection<TreeItem<Pair<AbstractUrl, String>>> result) {
  final List listChildren = list.getChildren(FAVORITES_ROOT);
  if (listChildren == null || listChildren.isEmpty()) return;

  for (Object favorite : listChildren) {
    final Element favoriteElement = (Element)favorite;
    final String className = favoriteElement.getAttributeValue(CLASS_NAME);
    final AbstractUrl abstractUrl = readUrlFromElement(favoriteElement, project);
    if (abstractUrl != null) {
      final TreeItem<Pair<AbstractUrl, String>> treeItem = new TreeItem<Pair<AbstractUrl, String>>(Pair.create(abstractUrl, className));
      result.add(treeItem);
      readFavoritesOneLevel(favoriteElement, project, treeItem.getChildren());
    }
  }
}