public void listRemoved(String listName) { FavoritesListener[] listeners = myListeners.toArray(new FavoritesListener[myListeners.size()]); for (FavoritesListener listener : listeners) { listener.listRemoved(listName); } }
public void rootsChanged(String listName) { FavoritesListener[] listeners = myListeners.toArray(new FavoritesListener[myListeners.size()]); for (FavoritesListener listener : listeners) { listener.rootsChanged(listName); } }
public synchronized boolean renameFavoritesList( @NotNull String oldName, @NotNull String newName) { if (myReadOnlyLists.contains(oldName)) return false; List<TreeItem<Pair<AbstractUrl, String>>> list = myName2FavoritesRoots.remove(oldName); if (list != null && newName.length() > 0) { myName2FavoritesRoots.put(newName, list); fireListeners.listRemoved(oldName); fireListeners.listAdded(newName); return true; } return false; }
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); } } fireListeners.rootsChanged(name); return true; }
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); fireListeners.rootsChanged(name); return true; } return false; }
public synchronized void createNewList( @NotNull String name, boolean readOnly, boolean allowsTree) { myName2FavoritesRoots.put(name, new ArrayList<TreeItem<Pair<AbstractUrl, String>>>()); if (readOnly) { myReadOnlyLists.add(name); } if (allowsTree) { myAllowsTreeLists.add(name); } fireListeners.listAdded(name); }
public void removeRootByIndexes(String name, List<Integer> elementsIndexes) { List<TreeItem<Pair<AbstractUrl, String>>> list = getFavoritesListRootUrls(name); assert list != null; for (Integer index : elementsIndexes.subList(0, elementsIndexes.size() - 1)) { assert index >= 0 && index < list.size(); final TreeItem<Pair<AbstractUrl, String>> item = list.get(index); list = item.getChildren(); } assert list != null && !list.isEmpty(); list.remove(elementsIndexes.get(elementsIndexes.size() - 1).intValue()); fireListeners.rootsChanged(name); }
public synchronized boolean addRoot( @NotNull String name, @NotNull List<AbstractTreeNode> parentElements, final AbstractTreeNode newElement, @Nullable AbstractTreeNode sibling) { final List<TreeItem<Pair<AbstractUrl, String>>> items = myName2FavoritesRoots.get(name); if (items == null) return false; AbstractUrl url = createUrlByElement(newElement.getValue(), myProject); if (url == null) return false; final TreeItem<Pair<AbstractUrl, String>> newItem = new TreeItem<Pair<AbstractUrl, String>>(Pair.create(url, newElement.getClass().getName())); if (parentElements.isEmpty()) { // directly to list if (sibling != null) { TreeItem<Pair<AbstractUrl, String>> after = null; AbstractUrl siblingUrl = createUrlByElement(sibling.getValue(), myProject); int idx = -1; for (int i = 0; i < items.size(); i++) { TreeItem<Pair<AbstractUrl, String>> item = items.get(i); if (item.getData().getFirst().equals(siblingUrl)) { idx = i; break; } } if (idx != -1) { items.add(idx, newItem); } else { items.add(newItem); } } else { items.add(newItem); } fireListeners.rootsChanged(name); return true; } Collection<TreeItem<Pair<AbstractUrl, String>>> list = items; TreeItem<Pair<AbstractUrl, String>> item = null; for (AbstractTreeNode obj : parentElements) { AbstractUrl objUrl = createUrlByElement(obj.getValue(), myProject); item = findNextItem(objUrl, list); if (item == null) return false; list = item.getChildren(); } if (sibling != null) { TreeItem<Pair<AbstractUrl, String>> after = null; AbstractUrl siblingUrl = createUrlByElement(sibling.getValue(), myProject); for (TreeItem<Pair<AbstractUrl, String>> treeItem : list) { if (treeItem.getData().getFirst().equals(siblingUrl)) { after = treeItem; break; } } if (after == null) { item.addChild(newItem); } else { item.addChildAfter(newItem, after); } } else { item.addChild(newItem); } fireListeners.rootsChanged(name); return true; }
public synchronized boolean removeFavoritesList(@NotNull String name) { if (myReadOnlyLists.contains(name)) return false; boolean result = myName2FavoritesRoots.remove(name) != null; fireListeners.listRemoved(name); return result; }
public synchronized void fireListeners(@NotNull final String listName) { fireListeners.rootsChanged(listName); }