Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
279,100 | boolean () { return myShowing; } | isTreeShowing |
279,101 | void () { if (isPassthroughMode()) return; if (isEdt()) { LOG.error("Must not be in event-dispatch thread"); } } | assertNotDispatchThread |
279,102 | void () { processDeferredActions(myDeferredSelections); processDeferredActions(myDeferredExpansions); } | processDeferredActions |
279,103 | void (@NotNull Set<Runnable> actions) { Runnable[] runnables = actions.toArray(ArrayUtil.EMPTY_RUNNABLE_ARRAY); actions.clear(); for (Runnable runnable : runnables) { runnable.run(); } } | processDeferredActions |
279,104 | ActionCallback (Object element) { return queueUpdate(element, true); } | queueUpdate |
279,105 | ActionCallback (Object fromElement, boolean updateStructure) { assertIsDispatchThread(); try { if (getUpdater() == null) { return ActionCallback.REJECTED; } ActionCallback result = new ActionCallback(); DefaultMutableTreeNode nodeToUpdate = null; boolean updateElementStructure = updateStructure; for (Object element = fromElement; element != null; element = getTreeStructure().getParentElement(element)) { DefaultMutableTreeNode node = getFirstNode(element); if (node != null) { nodeToUpdate = node; break; } updateElementStructure = true; // always update children if element does not exist } addSubtreeToUpdate(nodeToUpdate != null? nodeToUpdate : getRootNode(), new TreeRunnable("AbstractTreeUi.queueUpdate") { @Override public void perform() { result.setDone(); } }, updateElementStructure); return result; } catch (ProcessCanceledException e) { return ActionCallback.REJECTED; } } | queueUpdate |
279,106 | void () { result.setDone(); } | perform |
279,107 | void () { updateSubtree(getRootNode(), false); } | doUpdateFromRoot |
279,108 | void (@NotNull DefaultMutableTreeNode node, boolean canSmartExpand) { updateSubtree(new TreeUpdatePass(node), canSmartExpand); } | updateSubtree |
279,109 | void (@NotNull TreeUpdatePass pass, boolean canSmartExpand) { AbstractTreeUpdater updater = getUpdater(); if (updater != null) { updater.addSubtreeToUpdate(pass); } else { updateSubtreeNow(pass, canSmartExpand); } } | updateSubtree |
279,110 | void (@NotNull TreeUpdatePass pass, boolean canSmartExpand) { maybeSetBusyAndScheduleWaiterForReady(true, getElementFor(pass.getNode())); setHoldSize(true); boolean consumed = initRootNodeNowIfNeeded(pass); if (consumed) return; DefaultMutableTreeNode node = pass.getNode(); NodeDescriptor<?> descriptor = getDescriptorFrom(node); if (descriptor == null) return; if (pass.isUpdateStructure()) { setUpdaterState(new UpdaterTreeState(this)).beforeSubtreeUpdate(); boolean forceUpdate = true; TreePath path = getPathFor(node); boolean invisible = !myTree.isExpanded(path) && (path.getParentPath() == null || !myTree.isExpanded(path.getParentPath())); if (invisible && myUnbuiltNodes.contains(node)) { forceUpdate = false; } updateNodeChildren(node, pass, null, false, canSmartExpand, forceUpdate, false, pass.isUpdateChildren()); } else { updateRow(0, pass); } } | updateSubtreeNow |
279,111 | void (int row, @NotNull TreeUpdatePass pass) { LOG.debug("updateRow: ", row, " - ", pass); invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.updateRow") { @Override public void perform() { if (row >= getTree().getRowCount()) return; TreePath path = getTree().getPathForRow(row); if (path != null) { NodeDescriptor<?> descriptor = getDescriptorFrom(path.getLastPathComponent()); if (descriptor != null) { DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent(); maybeYield(() -> update(descriptor, false) .onSuccess(new TreeConsumer<>("AbstractTreeUi.updateRow: inner") { @Override public void perform() { updateRow(row + 1, pass); } }), pass, node); } } } }); } | updateRow |
279,112 | void () { if (row >= getTree().getRowCount()) return; TreePath path = getTree().getPathForRow(row); if (path != null) { NodeDescriptor<?> descriptor = getDescriptorFrom(path.getLastPathComponent()); if (descriptor != null) { DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent(); maybeYield(() -> update(descriptor, false) .onSuccess(new TreeConsumer<>("AbstractTreeUi.updateRow: inner") { @Override public void perform() { updateRow(row + 1, pass); } }), pass, node); } } } | perform |
279,113 | void () { updateRow(row + 1, pass); } | perform |
279,114 | boolean (NodeDescriptor<?> descriptor) { return isToBuildChildrenInBackground(getElementFromDescriptor(descriptor)); } | isToBuildInBackground |
279,115 | UpdaterTreeState (@NotNull UpdaterTreeState state) { if (state.equals(myUpdaterState)) return state; UpdaterTreeState oldState = myUpdaterState; if (oldState == null) { myUpdaterState = state; return state; } else { oldState.addAll(state); return oldState; } } | setUpdaterState |
279,116 | Object (NodeDescriptor<?> descriptor) { return getBuilder().getTreeStructureElement(descriptor); } | getElementFromDescriptor |
279,117 | ActionCallback (@NotNull DefaultMutableTreeNode node, @NotNull TreeUpdatePass pass, @Nullable LoadedChildren loadedChildren, boolean forcedNow, boolean toSmartExpand, boolean forceUpdate, boolean descriptorIsUpToDate, boolean updateChildren) { AbstractTreeStructure treeStructure = getTreeStructure(); ActionCallback result = treeStructure.asyncCommit(); result.doWhenDone(new TreeRunnable("AbstractTreeUi.updateNodeChildren: on done") { @Override public void perform() { try { removeFromCancelled(node); execute(new TreeRunnable("AbstractTreeUi.updateNodeChildren: execute") { @Override public void perform() { doUpdateChildren(node, pass, loadedChildren, forcedNow, toSmartExpand, forceUpdate, descriptorIsUpToDate, updateChildren); } }); } catch (ProcessCanceledException e) { addToCancelled(node); throw e; } } }); return result; } | updateNodeChildren |
279,118 | void () { try { removeFromCancelled(node); execute(new TreeRunnable("AbstractTreeUi.updateNodeChildren: execute") { @Override public void perform() { doUpdateChildren(node, pass, loadedChildren, forcedNow, toSmartExpand, forceUpdate, descriptorIsUpToDate, updateChildren); } }); } catch (ProcessCanceledException e) { addToCancelled(node); throw e; } } | perform |
279,119 | void () { doUpdateChildren(node, pass, loadedChildren, forcedNow, toSmartExpand, forceUpdate, descriptorIsUpToDate, updateChildren); } | perform |
279,120 | void (@NotNull DefaultMutableTreeNode node, @NotNull TreeUpdatePass pass, @Nullable LoadedChildren loadedChildren, boolean forcedNow, boolean toSmartExpand, boolean forceUpdate, boolean descriptorIsUpToDate, boolean updateChildren) { try { NodeDescriptor<?> descriptor = getDescriptorFrom(node); if (descriptor == null) { removeFromUnbuilt(node); removeLoading(node, true); return; } boolean descriptorIsReady = descriptorIsUpToDate || pass.isUpdated(descriptor); boolean wasExpanded = myTree.isExpanded(new TreePath(node.getPath())) || isAutoExpand(node); boolean wasLeaf = node.getChildCount() == 0; boolean bgBuild = isToBuildInBackground(descriptor); boolean requiredToUpdateChildren = forcedNow || wasExpanded; if (!requiredToUpdateChildren && forceUpdate) { boolean alwaysPlus = getBuilder().isAlwaysShowPlus(descriptor); if (alwaysPlus && wasLeaf) { requiredToUpdateChildren = true; } else { requiredToUpdateChildren = !alwaysPlus; if (!requiredToUpdateChildren && !myUnbuiltNodes.contains(node)) { removeChildren(node); } } } AtomicReference<LoadedChildren> preloaded = new AtomicReference<>(loadedChildren); if (!requiredToUpdateChildren) { if (myUnbuiltNodes.contains(node) && node.getChildCount() == 0) { insertLoadingNode(node, true); } if (!descriptorIsReady) { update(descriptor, false); } return; } if (!forcedNow && !bgBuild && myUnbuiltNodes.contains(node)) { if (!descriptorIsReady) { update(descriptor, true); descriptorIsReady = true; } if (processAlwaysLeaf(node) || !updateChildren) { return; } Pair<Boolean, LoadedChildren> unbuilt = processUnbuilt(node, descriptor, pass, wasExpanded, null); if (unbuilt.getFirst()) { return; } preloaded.set(unbuilt.getSecond()); } boolean childForceUpdate = isChildNodeForceUpdate(node, forceUpdate, wasExpanded); if (!forcedNow && isToBuildInBackground(descriptor)) { boolean alwaysLeaf = processAlwaysLeaf(node); queueBackgroundUpdate( new UpdateInfo(descriptor, pass, canSmartExpand(node, toSmartExpand), wasExpanded, childForceUpdate, descriptorIsReady, !alwaysLeaf && updateChildren), node); } else { if (!descriptorIsReady) { update(descriptor, false) .onSuccess(new TreeConsumer<>("AbstractTreeUi.doUpdateChildren") { @Override public void perform() { if (processAlwaysLeaf(node) || !updateChildren) return; updateNodeChildrenNow(node, pass, preloaded.get(), toSmartExpand, wasExpanded, childForceUpdate); } }); } else { if (processAlwaysLeaf(node) || !updateChildren) return; updateNodeChildrenNow(node, pass, preloaded.get(), toSmartExpand, wasExpanded, childForceUpdate); } } } finally { if (!isReleased()) { processNodeActionsIfReady(node); } } } | doUpdateChildren |
279,121 | void () { if (processAlwaysLeaf(node) || !updateChildren) return; updateNodeChildrenNow(node, pass, preloaded.get(), toSmartExpand, wasExpanded, childForceUpdate); } | perform |
279,122 | boolean (@NotNull DefaultMutableTreeNode node) { Object element = getElementFor(node); NodeDescriptor<?> desc = getDescriptorFrom(node); if (desc == null) return false; if (element != null && getTreeStructure().isAlwaysLeaf(element)) { removeFromUnbuilt(node); removeLoading(node, true); if (node.getChildCount() > 0) { TreeNode[] children = new TreeNode[node.getChildCount()]; for (int i = 0; i < node.getChildCount(); i++) { children[i] = node.getChildAt(i); } if (isSelectionInside(node)) { addSelectionPath(getPathFor(node), true, Conditions.alwaysTrue(), null); } processInnerChange(new TreeRunnable("AbstractTreeUi.processAlwaysLeaf") { @Override public void perform() { for (TreeNode each : children) { removeNodeFromParent((MutableTreeNode)each, true); disposeNode((DefaultMutableTreeNode)each); } } }); } removeFromUnbuilt(node); desc.setWasDeclaredAlwaysLeaf(true); processNodeActionsIfReady(node); return true; } else { boolean wasLeaf = desc.isWasDeclaredAlwaysLeaf(); desc.setWasDeclaredAlwaysLeaf(false); if (wasLeaf) { insertLoadingNode(node, true); } return false; } } | processAlwaysLeaf |
279,123 | void () { for (TreeNode each : children) { removeNodeFromParent((MutableTreeNode)each, true); disposeNode((DefaultMutableTreeNode)each); } } | perform |
279,124 | boolean (@NotNull DefaultMutableTreeNode node, boolean parentForceUpdate, boolean parentExpanded) { TreePath path = getPathFor(node); return parentForceUpdate && (parentExpanded || myTree.isExpanded(path)); } | isChildNodeForceUpdate |
279,125 | void (@NotNull DefaultMutableTreeNode node, @NotNull TreeUpdatePass pass, @Nullable LoadedChildren preloadedChildren, boolean toSmartExpand, boolean wasExpanded, boolean forceUpdate) { if (isUpdatingChildrenNow(node)) return; if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } NodeDescriptor<?> descriptor = getDescriptorFrom(node); MutualMap<Object, Integer> elementToIndexMap = loadElementsFromStructure(descriptor, preloadedChildren); LoadedChildren loadedChildren = preloadedChildren != null ? preloadedChildren : new LoadedChildren(elementToIndexMap.getKeys().toArray()); addToUpdatingChildren(node); pass.setCurrentNode(node); boolean canSmartExpand = canSmartExpand(node, toSmartExpand); removeFromUnbuilt(node); //noinspection unchecked processExistingNodes(node, elementToIndexMap, pass, canSmartExpand(node, toSmartExpand), forceUpdate, wasExpanded, preloadedChildren) .onSuccess(new TreeConsumer("AbstractTreeUi.updateNodeChildrenNow: on done processExistingNodes") { @Override public void perform() { if (isDisposed(node)) { removeFromUpdatingChildren(node); return; } removeLoading(node, false); boolean expanded = isExpanded(node, wasExpanded); if (expanded) { myWillBeExpanded.add(node); } else { myWillBeExpanded.remove(node); } collectNodesToInsert(descriptor, elementToIndexMap, node, expanded, loadedChildren) .doWhenDone((Consumer<List<TreeNode>>)nodesToInsert -> { insertNodesInto(nodesToInsert, node); ActionCallback callback = updateNodesToInsert(nodesToInsert, pass, canSmartExpand, isChildNodeForceUpdate(node, forceUpdate, expanded)); callback.doWhenDone(new TreeRunnable("AbstractTreeUi.updateNodeChildrenNow: on done updateNodesToInsert") { @Override public void perform() { removeLoading(node, false); removeFromUpdatingChildren(node); if (node.getChildCount() > 0) { if (expanded) { expand(node, canSmartExpand); } } if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } Object element = getElementFor(node); addNodeAction(element, false, node1 -> removeLoading(node1, false)); processNodeActionsIfReady(node); } }); }).doWhenProcessed(new TreeRunnable("AbstractTreeUi.updateNodeChildrenNow: on processed collectNodesToInsert") { @Override public void perform() { myWillBeExpanded.remove(node); removeFromUpdatingChildren(node); processNodeActionsIfReady(node); } }); } }) .onError(new TreeConsumer<>("AbstractTreeUi.updateNodeChildrenNow: on reject processExistingNodes") { @Override public void perform() { removeFromUpdatingChildren(node); processNodeActionsIfReady(node); } }); } | updateNodeChildrenNow |
279,126 | void () { if (isDisposed(node)) { removeFromUpdatingChildren(node); return; } removeLoading(node, false); boolean expanded = isExpanded(node, wasExpanded); if (expanded) { myWillBeExpanded.add(node); } else { myWillBeExpanded.remove(node); } collectNodesToInsert(descriptor, elementToIndexMap, node, expanded, loadedChildren) .doWhenDone((Consumer<List<TreeNode>>)nodesToInsert -> { insertNodesInto(nodesToInsert, node); ActionCallback callback = updateNodesToInsert(nodesToInsert, pass, canSmartExpand, isChildNodeForceUpdate(node, forceUpdate, expanded)); callback.doWhenDone(new TreeRunnable("AbstractTreeUi.updateNodeChildrenNow: on done updateNodesToInsert") { @Override public void perform() { removeLoading(node, false); removeFromUpdatingChildren(node); if (node.getChildCount() > 0) { if (expanded) { expand(node, canSmartExpand); } } if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } Object element = getElementFor(node); addNodeAction(element, false, node1 -> removeLoading(node1, false)); processNodeActionsIfReady(node); } }); }).doWhenProcessed(new TreeRunnable("AbstractTreeUi.updateNodeChildrenNow: on processed collectNodesToInsert") { @Override public void perform() { myWillBeExpanded.remove(node); removeFromUpdatingChildren(node); processNodeActionsIfReady(node); } }); } | perform |
279,127 | void () { removeLoading(node, false); removeFromUpdatingChildren(node); if (node.getChildCount() > 0) { if (expanded) { expand(node, canSmartExpand); } } if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } Object element = getElementFor(node); addNodeAction(element, false, node1 -> removeLoading(node1, false)); processNodeActionsIfReady(node); } | perform |
279,128 | void () { myWillBeExpanded.remove(node); removeFromUpdatingChildren(node); processNodeActionsIfReady(node); } | perform |
279,129 | void () { removeFromUpdatingChildren(node); processNodeActionsIfReady(node); } | perform |
279,130 | boolean (@NotNull DefaultMutableTreeNode node) { return !node.isNodeAncestor((DefaultMutableTreeNode)myTree.getModel().getRoot()); } | isDisposed |
279,131 | void (TreePath path) { assertIsDispatchThread(); try { mySilentExpand = path; getTree().expandPath(path); } finally { mySilentExpand = null; } } | expandSilently |
279,132 | void (TreePath path) { assertIsDispatchThread(); try { mySilentSelect = path; getTree().getSelectionModel().addSelectionPath(path); } finally { mySilentSelect = null; } } | addSelectionSilently |
279,133 | void (@NotNull DefaultMutableTreeNode node, boolean canSmartExpand) { expand(new TreePath(node.getPath()), canSmartExpand); } | expand |
279,134 | void (@NotNull TreePath path, boolean canSmartExpand) { Object last = path.getLastPathComponent(); boolean isLeaf = myTree.getModel().isLeaf(path.getLastPathComponent()); boolean isRoot = last == myTree.getModel().getRoot(); TreePath parent = path.getParentPath(); if (isRoot && !myTree.isExpanded(path)) { if (myTree.isRootVisible() || myUnbuiltNodes.contains(last)) { insertLoadingNode((DefaultMutableTreeNode)last, false); } expandPath(path, canSmartExpand); } else if (myTree.isExpanded(path) || isLeaf && parent != null && myTree.isExpanded(parent) && !myUnbuiltNodes.contains(last) && !isCancelled(last)) { if (last instanceof DefaultMutableTreeNode) { processNodeActionsIfReady((DefaultMutableTreeNode)last); } } else { if (isLeaf && (myUnbuiltNodes.contains(last) || isCancelled(last))) { insertLoadingNode((DefaultMutableTreeNode)last, true); expandPath(path, canSmartExpand); } else if (isLeaf && parent != null) { DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode)parent.getLastPathComponent(); if (parentNode != null) { addToUnbuilt(parentNode); } expandPath(parent, canSmartExpand); } else { expandPath(path, canSmartExpand); } } } | expand |
279,135 | void (DefaultMutableTreeNode node) { myUnbuiltNodes.add(node); } | addToUnbuilt |
279,136 | void (DefaultMutableTreeNode node) { myUnbuiltNodes.remove(node); } | removeFromUnbuilt |
279,137 | void () { if (!isExpanded && getBuilder().isAlwaysShowPlus(descriptor)) { result.set(new Pair<>(true, null)); return; } Object element = getElementFor(node); if (element == null) { trace("null element for node " + node); result.set(new Pair<>(true, null)); return; } addToUpdatingChildren(node); try { LoadedChildren children = loadedChildren != null ? loadedChildren : new LoadedChildren(getChildrenFor(element)); boolean processed; if (children.getElements().isEmpty()) { removeFromUnbuilt(node); removeLoading(node, true); processed = true; } else { if (isAutoExpand(node)) { addNodeAction(getElementFor(node), false, node1 -> { TreePath path = new TreePath(node1.getPath()); if (getTree().isExpanded(path) || children.getElements().isEmpty()) { removeLoading(node1, false); } else { maybeYield(() -> { expand(element, null); return Promises.resolvedPromise(); }, pass, node1); } }); } processed = false; } removeFromUpdatingChildren(node); processNodeActionsIfReady(node); result.set(new Pair<>(processed, children)); } finally { removeFromUpdatingChildren(node); } } | perform |
279,138 | boolean (@NotNull TreeNode node) { if (isLoadingNode(node)) { moveSelectionToParentIfNeeded(node); removeNodeFromParent((MutableTreeNode)node, false); return true; } return false; } | removeIfLoading |
279,139 | void (@NotNull TreeNode node) { TreePath path = getPathFor(node); if (myTree.getSelectionModel().isPathSelected(path)) { TreePath parentPath = path.getParentPath(); myTree.getSelectionModel().removeSelectionPath(path); if (parentPath != null) { myTree.getSelectionModel().addSelectionPath(parentPath); } } } | moveSelectionToParentIfNeeded |
279,140 | Object[] (Object element) { Ref<Object[]> passOne = new Ref<>(); try (LockToken ignored = acquireLock()) { execute(new TreeRunnable("AbstractTreeUi.getChildrenFor") { @Override public void perform() { passOne.set(getTreeStructure().getChildElements(element)); } }); } catch (IndexNotReadyException e) { warnOnIndexNotReady(e); return ArrayUtilRt.EMPTY_OBJECT_ARRAY; } if (!Registry.is("ide.tree.checkStructure")) return passOne.get(); Object[] passTwo = getTreeStructure().getChildElements(element); Set<Object> two = ContainerUtil.newHashSet(passTwo); if (passOne.get().length != passTwo.length) { LOG.error( "AbstractTreeStructure.getChildren() must either provide same objects or new objects but with correct hashCode() and equals() methods. Wrong parent element=" + element); } else { for (Object eachInOne : passOne.get()) { if (!two.contains(eachInOne)) { LOG.error( "AbstractTreeStructure.getChildren() must either provide same objects or new objects but with correct hashCode() and equals() methods. Wrong parent element=" + element); break; } } } return passOne.get(); } | getChildrenFor |
279,141 | void () { passOne.set(getTreeStructure().getChildElements(element)); } | perform |
279,142 | void (IndexNotReadyException e) { if (!myWasEverIndexNotReady) { myWasEverIndexNotReady = true; LOG.error("Tree is not dumb-mode-aware; treeBuilder=" + getBuilder() + " treeStructure=" + getTreeStructure(), e); } } | warnOnIndexNotReady |
279,143 | ActionCallback (@NotNull List<? extends TreeNode> nodesToInsert, @NotNull TreeUpdatePass pass, boolean canSmartExpand, boolean forceUpdate) { ActionCallback.Chunk chunk = new ActionCallback.Chunk(); for (TreeNode node : nodesToInsert) { DefaultMutableTreeNode childNode = (DefaultMutableTreeNode)node; ActionCallback callback = updateNodeChildren(childNode, pass, null, false, canSmartExpand, forceUpdate, true, true); if (!callback.isDone()) { chunk.add(callback); } } return chunk.getWhenProcessed(); } | updateNodesToInsert |
279,144 | boolean (@NotNull TreeUpdatePass pass) { if (pass.isExpired() || !canInitiateNewActivity()) return false; boolean rerunBecauseTreeIsHidden = !pass.isExpired() && !isTreeShowing() && getUpdater().isInPostponeMode(); return rerunBecauseTreeIsHidden || getUpdater().isRerunNeededFor(pass); } | isRerunNeeded |
279,145 | void () { if (pass.isExpired()) { result.setError("expired"); return; } if (isRerunNeeded(pass)) { runDone(new TreeRunnable("AbstractTreeUi.maybeYield: rerun") { @Override public void perform() { if (!pass.isExpired()) { queueUpdate(getElementFor(node)); } } }); result.setError("requeue"); } else { try { //noinspection unchecked execute(processRunnable).processed((Promise)result); } catch (ProcessCanceledException e) { pass.expire(); cancelUpdate(); result.setError("rejected"); } } } | perform |
279,146 | void () { if (!pass.isExpired()) { queueUpdate(getElementFor(node)); } } | perform |
279,147 | boolean () { return !isCancelProcessed() && !myReleaseRequested && !isReleased(); } | canInitiateNewActivity |
279,148 | void () { if (isReady()) { return; } if (myResettingToReadyNow.get()) { _getReady(); return; } myResettingToReadyNow.set(true); invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.resetToReady: later") { @Override public void perform() { if (!myResettingToReadyNow.get()) { return; } Progressive[] progressives = myBatchIndicators.keySet().toArray(new Progressive[0]); for (Progressive each : progressives) { myBatchIndicators.remove(each).cancel(); myBatchCallbacks.remove(each).setRejected(); } resetToReadyNow(); } }); } | resetToReady |
279,149 | void () { if (!myResettingToReadyNow.get()) { return; } Progressive[] progressives = myBatchIndicators.keySet().toArray(new Progressive[0]); for (Progressive each : progressives) { myBatchIndicators.remove(each).cancel(); myBatchCallbacks.remove(each).setRejected(); } resetToReadyNow(); } | perform |
279,150 | ActionCallback () { if (isReleased()) return ActionCallback.REJECTED; assertIsDispatchThread(); DefaultMutableTreeNode[] uc; synchronized (myUpdatingChildren) { uc = myUpdatingChildren.toArray(new DefaultMutableTreeNode[0]); } for (DefaultMutableTreeNode each : uc) { resetIncompleteNode(each); } Object[] bg = ArrayUtil.toObjectArray(myLoadedInBackground.keySet()); for (Object each : bg) { DefaultMutableTreeNode node = getNodeForElement(each, false); if (node != null) { resetIncompleteNode(node); } } myUpdaterState = null; getUpdater().reset(); myYieldingNow = false; myYieldingPasses.clear(); myYieldingDoneRunnables.clear(); myNodeActions.clear(); myNodeChildrenActions.clear(); synchronized (myUpdatingChildren) { myUpdatingChildren.clear(); } myLoadedInBackground.clear(); myDeferredExpansions.clear(); myDeferredSelections.clear(); ActionCallback result = _getReady(); result.doWhenDone(new TreeRunnable("AbstractTreeUi.resetToReadyNow: on done") { @Override public void perform() { myResettingToReadyNow.set(false); setCancelRequested(false); } }); maybeReady(); return result; } | resetToReadyNow |
279,151 | void () { myResettingToReadyNow.set(false); setCancelRequested(false); } | perform |
279,152 | void (@NotNull DefaultMutableTreeNode node) { myCancelledBuild.remove(node); } | removeFromCancelled |
279,153 | boolean (@NotNull Object node) { return node instanceof DefaultMutableTreeNode && myCancelledBuild.containsKey(node); } | isCancelled |
279,154 | void (@NotNull DefaultMutableTreeNode node) { if (myReleaseRequested) return; addToCancelled(node); if (!isExpanded(node, false)) { node.removeAllChildren(); Object element = getElementFor(node); if (element != null && !getTreeStructure().isAlwaysLeaf(element)) { insertLoadingNode(node, true); } } else { removeFromUnbuilt(node); removeLoading(node, true); } } | resetIncompleteNode |
279,155 | boolean (@NotNull Runnable runnable, @NotNull TreeUpdatePass pass) { myYieldingPasses.add(pass); myYieldingNow = true; yieldToEDT(new TreeRunnable("AbstractTreeUi.yieldAndRun") { @Override public void perform() { if (isReleased()) return; runOnYieldingDone(new TreeRunnable("AbstractTreeUi.yieldAndRun: inner") { @Override public void perform() { if (isReleased()) return; executeYieldingRequest(runnable, pass); } }); } }); return true; } | yieldAndRun |
279,156 | void () { if (isReleased()) return; runOnYieldingDone(new TreeRunnable("AbstractTreeUi.yieldAndRun: inner") { @Override public void perform() { if (isReleased()) return; executeYieldingRequest(runnable, pass); } }); } | perform |
279,157 | void () { if (isReleased()) return; executeYieldingRequest(runnable, pass); } | perform |
279,158 | boolean () { return myYieldingNow; } | isYieldingNow |
279,159 | boolean () { return getUpdater().hasNodesToUpdate(); } | hasScheduledUpdates |
279,160 | boolean () { return isReady(false); } | isReady |
279,161 | boolean (boolean attempt) { if (attempt && myStateLock.isLocked()) return false; try (LockToken ignored = attempt ? attemptLock() : acquireLock()) { return isIdle() && !hasPendingWork() && !isNodeActionsPending(); } catch (InterruptedException e) { LOG.info(e); return false; } } | isReady |
279,162 | boolean () { return hasNodesToUpdate() || myUpdaterState != null && myUpdaterState.isProcessingNow() || hasScheduledUpdates() && !getUpdater().isInPostponeMode(); } | hasPendingWork |
279,163 | boolean () { return !isYieldingNow() && !isWorkerBusy() && !hasUpdatingChildrenNow() && !isLoadingInBackgroundNow(); } | isIdle |
279,164 | void (@NotNull Runnable runnable, @NotNull TreeUpdatePass pass) { try { try { myYieldingPasses.remove(pass); if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } runnable.run(); } finally { if (!isReleased()) { maybeYieldingFinished(); } } } catch (ProcessCanceledException e) { resetToReady(); } } | executeYieldingRequest |
279,165 | void () { if (myYieldingPasses.isEmpty()) { myYieldingNow = false; flushPendingNodeActions(); } } | maybeYieldingFinished |
279,166 | void () { DefaultMutableTreeNode[] nodes = myPendingNodeActions.toArray(new DefaultMutableTreeNode[0]); myPendingNodeActions.clear(); for (DefaultMutableTreeNode each : nodes) { processNodeActionsIfReady(each); } Runnable[] actions = myYieldingDoneRunnables.toArray(ArrayUtil.EMPTY_RUNNABLE_ARRAY); for (Runnable each : actions) { if (!isYieldingNow()) { myYieldingDoneRunnables.remove(each); each.run(); } } maybeReady(); } | flushPendingNodeActions |
279,167 | void (@NotNull Runnable onDone) { getBuilder().runOnYieldingDone(onDone); } | runOnYieldingDone |
279,168 | void (@NotNull Runnable runnable) { getBuilder().yieldToEDT(runnable); } | yieldToEDT |
279,169 | boolean (Object node) { return node instanceof LoadingNode; } | isLoadingNode |
279,170 | AsyncResult<List<TreeNode>> (NodeDescriptor<?> descriptor, @NotNull MutualMap<Object, Integer> elementToIndexMap, DefaultMutableTreeNode parent, boolean addLoadingNode, @NotNull LoadedChildren loadedChildren) { AsyncResult<List<TreeNode>> result = new AsyncResult<>(); List<TreeNode> nodesToInsert = new ArrayList<>(); Collection<Object> allElements = elementToIndexMap.getKeys(); ActionCallback processingDone = allElements.isEmpty() ? ActionCallback.DONE : new ActionCallback(allElements.size()); for (Object child : allElements) { Integer index = elementToIndexMap.getValue(child); boolean needToUpdate = false; NodeDescriptor<?> loadedDesc = loadedChildren.getDescriptor(child); NodeDescriptor<?> childDescr; if (!isValid(loadedDesc, descriptor)) { childDescr = getTreeStructure().createDescriptor(child, descriptor); needToUpdate = true; } else { childDescr = loadedDesc; } if (index == null) { index = Integer.MAX_VALUE; needToUpdate = true; } childDescr.setIndex(index.intValue()); ActionCallback update = new ActionCallback(); if (needToUpdate) { update(childDescr, false) .onSuccess(changes -> { loadedChildren.putDescriptor(child, childDescr, changes); update.setDone(); }); } else { update.setDone(); } update.doWhenDone(new TreeRunnable("AbstractTreeUi.collectNodesToInsert: on done update") { @Override public void perform() { Object element = getElementFromDescriptor(childDescr); if (!isNodeNull(element)) { DefaultMutableTreeNode node = getNodeForElement(element, false); if (node == null || node.getParent() != parent) { DefaultMutableTreeNode childNode = createChildNode(childDescr); if (addLoadingNode || getBuilder().isAlwaysShowPlus(childDescr)) { insertLoadingNode(childNode, true); } else { addToUnbuilt(childNode); } nodesToInsert.add(childNode); createMapping(element, childNode); } } processingDone.setDone(); } }); } processingDone.doWhenDone(new TreeRunnable("AbstractTreeUi.collectNodesToInsert: on done processing") { @Override public void perform() { result.setDone(nodesToInsert); } }); return result; } | collectNodesToInsert |
279,171 | void () { Object element = getElementFromDescriptor(childDescr); if (!isNodeNull(element)) { DefaultMutableTreeNode node = getNodeForElement(element, false); if (node == null || node.getParent() != parent) { DefaultMutableTreeNode childNode = createChildNode(childDescr); if (addLoadingNode || getBuilder().isAlwaysShowPlus(childDescr)) { insertLoadingNode(childNode, true); } else { addToUnbuilt(childNode); } nodesToInsert.add(childNode); createMapping(element, childNode); } } processingDone.setDone(); } | perform |
279,172 | void () { result.setDone(nodesToInsert); } | perform |
279,173 | DefaultMutableTreeNode (NodeDescriptor<?> descriptor) { return new ElementNode(this, descriptor); } | createChildNode |
279,174 | boolean () { return myCanYield && myYieldingUpdate.asBoolean(); } | canYield |
279,175 | long () { return myClearOnHideDelay; } | getClearOnHideDelay |
279,176 | ActionCallback () { return myInitialized; } | getInitialized |
279,177 | ActionCallback (@NotNull Object requestor) { return myBusyObject.getReady(requestor); } | getReady |
279,178 | ActionCallback () { return getReady(this); } | _getReady |
279,179 | void (@NotNull DefaultMutableTreeNode node) { synchronized (myUpdatingChildren) { myUpdatingChildren.add(node); } } | addToUpdatingChildren |
279,180 | void (@NotNull DefaultMutableTreeNode node) { synchronized (myUpdatingChildren) { myUpdatingChildren.remove(node); } } | removeFromUpdatingChildren |
279,181 | boolean () { synchronized (myUpdatingChildren) { return !myUpdatingChildren.isEmpty(); } } | hasUpdatingChildrenNow |
279,182 | List<Object> () { List<Object> result = new ArrayList<>(); if (isReleased()) return result; Enumeration<TreePath> enumeration = myTree.getExpandedDescendants(getPathFor(getRootNode())); if (enumeration != null) { while (enumeration.hasMoreElements()) { TreePath each = enumeration.nextElement(); Object eachElement = getElementFor(each.getLastPathComponent()); if (eachElement != null) { result.add(eachElement); } } } return result; } | getExpandedElements |
279,183 | ActionCallback () { if (isReleased()) return ActionCallback.REJECTED; setCancelRequested(true); ActionCallback done = new ActionCallback(); invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.cancelUpdate") { @Override public void perform() { if (isReleased()) { done.setRejected(); return; } if (myResettingToReadyNow.get()) { _getReady().notify(done); } else if (isReady()) { resetToReadyNow(); done.setDone(); } else { if (isIdle() && hasPendingWork()) { resetToReadyNow(); done.setDone(); } else { _getReady().notify(done); } } maybeReady(); } }); if (isEdt() || isPassthroughMode()) { maybeReady(); } return done; } | cancelUpdate |
279,184 | void () { if (isReleased()) { done.setRejected(); return; } if (myResettingToReadyNow.get()) { _getReady().notify(done); } else if (isReady()) { resetToReadyNow(); done.setDone(); } else { if (isIdle() && hasPendingWork()) { resetToReadyNow(); done.setDone(); } else { _getReady().notify(done); } } maybeReady(); } | perform |
279,185 | void (boolean requested) { try (LockToken ignored = isUnitTestingMode() ? acquireLock() : attemptLock()) { myCancelRequest.set(requested); } catch (InterruptedException ignored) { } } | setCancelRequested |
279,186 | LockToken () { return LockToken.acquireLock(myStateLock); } | acquireLock |
279,187 | ActionCallback (@NotNull Progressive progressive) { assertIsDispatchThread(); EmptyProgressIndicator indicator = new EmptyProgressIndicator(); ActionCallback callback = new ActionCallback(); myBatchIndicators.put(progressive, indicator); myBatchCallbacks.put(progressive, callback); try { progressive.run(indicator); } catch (ProcessCanceledException e) { resetToReadyNow().doWhenProcessed(new TreeRunnable("AbstractTreeUi.batch: catch") { @Override public void perform() { callback.setRejected(); } }); return callback; } finally { if (isReleased()) return ActionCallback.REJECTED; _getReady().doWhenDone(new TreeRunnable("AbstractTreeUi.batch: finally") { @Override public void perform() { if (myBatchIndicators.containsKey(progressive)) { ProgressIndicator indicator = myBatchIndicators.remove(progressive); myBatchCallbacks.remove(progressive); if (indicator.isCanceled()) { callback.setRejected(); } else { callback.setDone(); } } else { callback.setRejected(); } } }); maybeReady(); } return callback; } | batch |
279,188 | void () { callback.setRejected(); } | perform |
279,189 | void () { if (myBatchIndicators.containsKey(progressive)) { ProgressIndicator indicator = myBatchIndicators.remove(progressive); myBatchCallbacks.remove(progressive); if (indicator.isCanceled()) { callback.setRejected(); } else { callback.setDone(); } } else { callback.setRejected(); } } | perform |
279,190 | void (@NotNull Runnable runnable) { try { myUserRunnables.add(runnable); runnable.run(); } finally { myUserRunnables.remove(runnable); } } | executeUserRunnable |
279,191 | void (MutableTreeNode newChild, int childIndex) { super.insert(newChild, childIndex); Object element = myUi.getElementFor(newChild); if (element != null) { myElements.add(element); } } | insert |
279,192 | void (int childIndex) { TreeNode node = getChildAt(childIndex); super.remove(childIndex); Object element = myUi.getElementFor(node); if (element != null) { myElements.remove(element); } } | remove |
279,193 | String () { return String.valueOf(getUserObject()); } | toString |
279,194 | boolean (DefaultMutableTreeNode kid) { return getUpdatingParent(kid) != null; } | isUpdatingParent |
279,195 | boolean (Object element) { return getLoadedInBackground(element) != null; } | isLoadedInBackground |
279,196 | UpdateInfo (Object element) { synchronized (myLoadedInBackground) { return isNodeNull(element) ? null : myLoadedInBackground.get(element); } } | getLoadedInBackground |
279,197 | void (Object element, UpdateInfo info) { if (isNodeNull(element)) return; synchronized (myLoadedInBackground) { warnMap("put into myLoadedInBackground: ", myLoadedInBackground); myLoadedInBackground.put(element, info); } } | addToLoadedInBackground |
279,198 | void (Object element) { if (isNodeNull(element)) return; synchronized (myLoadedInBackground) { warnMap("remove from myLoadedInBackground: ", myLoadedInBackground); myLoadedInBackground.remove(element); } } | removeFromLoadedInBackground |
279,199 | boolean () { synchronized (myLoadedInBackground) { return !myLoadedInBackground.isEmpty(); } } | isLoadingInBackgroundNow |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.