Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
279,200 | void (@NotNull UpdateInfo updateInfo, @NotNull DefaultMutableTreeNode node) { assertIsDispatchThread(); Object oldElementFromDescriptor = getElementFromDescriptor(updateInfo.getDescriptor()); if (isNodeNull(oldElementFromDescriptor)) return; UpdateInfo loaded = getLoadedInBackground(oldElementFromDescriptor); if (loaded != null) { loaded.apply(updateInfo); return; } addToLoadedInBackground(oldElementFromDescriptor, updateInfo); maybeSetBusyAndScheduleWaiterForReady(true, oldElementFromDescriptor); if (!isNodeBeingBuilt(node)) { LoadingNode loadingNode = new LoadingNode(getLoadingNodeText()); myTreeModel.insertNodeInto(loadingNode, node, node.getChildCount()); } removeFromUnbuilt(node); Ref<LoadedChildren> children = new Ref<>(); Ref<Object> elementFromDescriptor = new Ref<>(); DefaultMutableTreeNode[] nodeToProcessActions = new DefaultMutableTreeNode[1]; TreeConsumer<Void> finalizeRunnable = new TreeConsumer<>("AbstractTreeUi.queueBackgroundUpdate: finalize") { @Override public void perform() { invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.queueBackgroundUpdate: finalize later") { @Override public void perform() { if (isReleased()) return; removeLoading(node, false); removeFromLoadedInBackground(elementFromDescriptor.get()); removeFromLoadedInBackground(oldElementFromDescriptor); if (nodeToProcessActions[0] != null) { processNodeActionsIfReady(nodeToProcessActions[0]); } } }); } }; Runnable buildRunnable = new TreeRunnable("AbstractTreeUi.queueBackgroundUpdate: build") { @Override public void perform() { if (updateInfo.getPass().isExpired()) { finalizeRunnable.run(); return; } if (!updateInfo.isDescriptorIsUpToDate()) { update(updateInfo.getDescriptor(), true); } if (!updateInfo.isUpdateChildren()) { nodeToProcessActions[0] = node; return; } Object element = getElementFromDescriptor(updateInfo.getDescriptor()); if (element == null) { removeFromLoadedInBackground(oldElementFromDescriptor); finalizeRunnable.run(); return; } elementFromDescriptor.set(element); Object[] loadedElements = getChildrenFor(element); LoadedChildren loaded = new LoadedChildren(loadedElements); for (Object each : loadedElements) { NodeDescriptor<?> existingDesc = getDescriptorFrom(getNodeForElement(each, true)); NodeDescriptor<?> eachChildDescriptor = isValid(existingDesc, updateInfo.getDescriptor()) ? existingDesc : getTreeStructure().createDescriptor(each, updateInfo.getDescriptor()); execute(new TreeRunnable("AbstractTreeUi.queueBackgroundUpdate") { @Override public void perform() { try { loaded.putDescriptor(each, eachChildDescriptor, update(eachChildDescriptor, true).blockingGet(0)); } catch (TimeoutException | ExecutionException e) { LOG.error(e); } } }); } children.set(loaded); } @Override public @NotNull @NonNls String toString() { return "runnable=" + oldElementFromDescriptor; } }; Runnable updateRunnable = new TreeRunnable("AbstractTreeUi.queueBackgroundUpdate: update") { @Override public void perform() { if (updateInfo.getPass().isExpired()) { finalizeRunnable.run(); return; } if (children.get() == null) { finalizeRunnable.run(); return; } if (isRerunNeeded(updateInfo.getPass())) { removeFromLoadedInBackground(elementFromDescriptor.get()); getUpdater().requeue(updateInfo.getPass()); return; } removeFromLoadedInBackground(elementFromDescriptor.get()); if (myUnbuiltNodes.contains(node)) { Pair<Boolean, LoadedChildren> unbuilt = processUnbuilt(node, updateInfo.getDescriptor(), updateInfo.getPass(), isExpanded(node, updateInfo.isWasExpanded()), children.get()); if (unbuilt.getFirst()) { nodeToProcessActions[0] = node; return; } } ActionCallback callback = updateNodeChildren(node, updateInfo.getPass(), children.get(), true, updateInfo.isCanSmartExpand(), updateInfo.isForceUpdate(), true, true); callback.doWhenDone(new TreeRunnable("AbstractTreeUi.queueBackgroundUpdate: on done updateNodeChildren") { @Override public void perform() { if (isRerunNeeded(updateInfo.getPass())) { getUpdater().requeue(updateInfo.getPass()); return; } Object element = elementFromDescriptor.get(); if (element != null) { removeLoading(node, false); nodeToProcessActions[0] = node; } } }); } }; queueToBackground(buildRunnable, updateRunnable) .onSuccess(finalizeRunnable) .onError(new TreeConsumer<>("AbstractTreeUi.queueBackgroundUpdate: on rejected") { @Override public void perform() { updateInfo.getPass().expire(); } }); } | queueBackgroundUpdate |
279,201 | void () { invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.queueBackgroundUpdate: finalize later") { @Override public void perform() { if (isReleased()) return; removeLoading(node, false); removeFromLoadedInBackground(elementFromDescriptor.get()); removeFromLoadedInBackground(oldElementFromDescriptor); if (nodeToProcessActions[0] != null) { processNodeActionsIfReady(nodeToProcessActions[0]); } } }); } | perform |
279,202 | void () { if (isReleased()) return; removeLoading(node, false); removeFromLoadedInBackground(elementFromDescriptor.get()); removeFromLoadedInBackground(oldElementFromDescriptor); if (nodeToProcessActions[0] != null) { processNodeActionsIfReady(nodeToProcessActions[0]); } } | perform |
279,203 | void () { if (updateInfo.getPass().isExpired()) { finalizeRunnable.run(); return; } if (!updateInfo.isDescriptorIsUpToDate()) { update(updateInfo.getDescriptor(), true); } if (!updateInfo.isUpdateChildren()) { nodeToProcessActions[0] = node; return; } Object element = getElementFromDescriptor(updateInfo.getDescriptor()); if (element == null) { removeFromLoadedInBackground(oldElementFromDescriptor); finalizeRunnable.run(); return; } elementFromDescriptor.set(element); Object[] loadedElements = getChildrenFor(element); LoadedChildren loaded = new LoadedChildren(loadedElements); for (Object each : loadedElements) { NodeDescriptor<?> existingDesc = getDescriptorFrom(getNodeForElement(each, true)); NodeDescriptor<?> eachChildDescriptor = isValid(existingDesc, updateInfo.getDescriptor()) ? existingDesc : getTreeStructure().createDescriptor(each, updateInfo.getDescriptor()); execute(new TreeRunnable("AbstractTreeUi.queueBackgroundUpdate") { @Override public void perform() { try { loaded.putDescriptor(each, eachChildDescriptor, update(eachChildDescriptor, true).blockingGet(0)); } catch (TimeoutException | ExecutionException e) { LOG.error(e); } } }); } children.set(loaded); } | perform |
279,204 | void () { try { loaded.putDescriptor(each, eachChildDescriptor, update(eachChildDescriptor, true).blockingGet(0)); } catch (TimeoutException | ExecutionException e) { LOG.error(e); } } | perform |
279,205 | void () { if (updateInfo.getPass().isExpired()) { finalizeRunnable.run(); return; } if (children.get() == null) { finalizeRunnable.run(); return; } if (isRerunNeeded(updateInfo.getPass())) { removeFromLoadedInBackground(elementFromDescriptor.get()); getUpdater().requeue(updateInfo.getPass()); return; } removeFromLoadedInBackground(elementFromDescriptor.get()); if (myUnbuiltNodes.contains(node)) { Pair<Boolean, LoadedChildren> unbuilt = processUnbuilt(node, updateInfo.getDescriptor(), updateInfo.getPass(), isExpanded(node, updateInfo.isWasExpanded()), children.get()); if (unbuilt.getFirst()) { nodeToProcessActions[0] = node; return; } } ActionCallback callback = updateNodeChildren(node, updateInfo.getPass(), children.get(), true, updateInfo.isCanSmartExpand(), updateInfo.isForceUpdate(), true, true); callback.doWhenDone(new TreeRunnable("AbstractTreeUi.queueBackgroundUpdate: on done updateNodeChildren") { @Override public void perform() { if (isRerunNeeded(updateInfo.getPass())) { getUpdater().requeue(updateInfo.getPass()); return; } Object element = elementFromDescriptor.get(); if (element != null) { removeLoading(node, false); nodeToProcessActions[0] = node; } } }); } | perform |
279,206 | void () { if (isRerunNeeded(updateInfo.getPass())) { getUpdater().requeue(updateInfo.getPass()); return; } Object element = elementFromDescriptor.get(); if (element != null) { removeLoading(node, false); nodeToProcessActions[0] = node; } } | perform |
279,207 | void () { updateInfo.getPass().expire(); } | perform |
279,208 | boolean (@NotNull DefaultMutableTreeNode node, boolean isExpanded) { return isExpanded || myTree.isExpanded(getPathFor(node)); } | isExpanded |
279,209 | void (@NotNull DefaultMutableTreeNode parent, boolean forced) { if (!forced && myUnbuiltNodes.contains(parent) && !myCancelledBuild.containsKey(parent)) { return; } boolean reallyRemoved = false; for (int i = 0; i < parent.getChildCount(); i++) { TreeNode child = parent.getChildAt(i); if (removeIfLoading(child)) { reallyRemoved = true; i--; } } maybeReady(); if (reallyRemoved) { nodeStructureChanged(parent); } } | removeLoading |
279,210 | void (@NotNull DefaultMutableTreeNode node) { assertIsDispatchThread(); if (isNodeBeingBuilt(node)) return; NodeDescriptor<?> descriptor = getDescriptorFrom(node); if (descriptor == null) return; if (isYieldingNow()) { myPendingNodeActions.add(node); return; } Object element = getElementFromDescriptor(descriptor); boolean childrenReady = !isLoadedInBackground(element) && !isUpdatingChildrenNow(node); processActions(node, element, myNodeActions, childrenReady ? myNodeChildrenActions : null); if (childrenReady) { processActions(node, element, myNodeChildrenActions, null); } warnMap("myNodeActions: processNodeActionsIfReady: ", myNodeActions); warnMap("myNodeChildrenActions: processNodeActionsIfReady: ", myNodeChildrenActions); if (!isUpdatingParent(node) && !isWorkerBusy()) { UpdaterTreeState state = myUpdaterState; if (myNodeActions.isEmpty() && state != null && !state.isProcessingNow()) { if (canInitiateNewActivity()) { if (!state.restore(childrenReady ? node : null)) { setUpdaterState(state); } } } } maybeReady(); } | processNodeActionsIfReady |
279,211 | void (@NotNull DefaultMutableTreeNode node, Object element, @NotNull Map<Object, List<NodeAction>> nodeActions, @Nullable Map<Object, List<NodeAction>> secondaryNodeAction) { List<NodeAction> actions = nodeActions.get(element); if (actions != null) { nodeActions.remove(element); List<NodeAction> secondary = secondaryNodeAction != null ? secondaryNodeAction.get(element) : null; for (NodeAction each : actions) { if (secondary != null) { secondary.remove(each); } each.onReady(node); } } } | processActions |
279,212 | boolean (DefaultMutableTreeNode node, boolean canSmartExpand) { if (!canInitiateNewActivity()) return false; if (!getBuilder().isSmartExpand()) return false; boolean smartExpand = canSmartExpand && !myNotForSmartExpand.contains(node); Object element = getElementFor(node); return smartExpand && element != null && validateAutoExpand(true, element); } | canSmartExpand |
279,213 | void (@NotNull DefaultMutableTreeNode node, boolean canSmartExpand, boolean forced) { if (!canInitiateNewActivity()) return; if (!getBuilder().isSmartExpand()) return; boolean can = canSmartExpand(node, canSmartExpand); if (!can && !forced) return; if (isNodeBeingBuilt(node) && !forced) { addNodeAction(getElementFor(node), true, node1 -> processSmartExpand(node1, canSmartExpand, true)); } else { TreeNode child = getChildForSmartExpand(node); if (child != null) { TreePath childPath = new TreePath(node.getPath()).pathByAddingChild(child); processInnerChange(new TreeRunnable("AbstractTreeUi.processSmartExpand") { @Override public void perform() { myTree.expandPath(childPath); } }); } } } | processSmartExpand |
279,214 | void () { myTree.expandPath(childPath); } | perform |
279,215 | boolean (Object nodeObject) { if (!(nodeObject instanceof DefaultMutableTreeNode node)) return false; int loadingNodes = 0; for (int i = 0; i < Math.min(node.getChildCount(), 2); i++) { TreeNode child = node.getChildAt(i); if (isLoadingNode(child)) { loadingNodes++; } } return loadingNodes > 0 && loadingNodes == node.getChildCount(); } | isLoadingChildrenFor |
279,216 | void () { if (childDesc.get().getIndex() != index.intValue()) { changes.set(true); } childDesc.get().setIndex(index.intValue()); } | perform |
279,217 | void () { if (!oldElement.equals(newElement.get()) || forceRemapping.get()) { removeMapping(oldElement, childNode, newElement.get()); Object newE = newElement.get(); if (!isNodeNull(newE)) { createMapping(newE, childNode); } NodeDescriptor<?> parentDescriptor = getDescriptorFrom(parentNode); if (parentDescriptor != null) { parentDescriptor.setChildrenSortingStamp(-1); } } if (index == null) { int selectedIndex = -1; if (TreeBuilderUtil.isNodeOrChildSelected(myTree, childNode)) { selectedIndex = parentNode.getIndex(childNode); } if (childNode.getParent() instanceof DefaultMutableTreeNode parent) { if (myTree.isExpanded(new TreePath(parent.getPath()))) { if (parent.getChildCount() == 1 && parent.getChildAt(0) == childNode) { insertLoadingNode(parent, false); } } } Object disposedElement = getElementFor(childNode); removeNodeFromParent(childNode, selectedIndex >= 0); disposeNode(childNode); adjustSelectionOnChildRemove(parentNode, selectedIndex, disposedElement); result.setResult(null); } else { elementToIndexMap.remove(getElementFromDescriptor(childDesc.get())); updateNodeChildren(childNode, pass, null, false, canSmartExpand, forceUpdate, true, true) .doWhenDone(() -> result.setResult(null)); } } | perform |
279,218 | void (@NotNull DefaultMutableTreeNode parentNode, int selectedIndex, Object disposedElement) { if (selectedIndex >= 0 && !getSelectedElements().isEmpty()) return; DefaultMutableTreeNode node = disposedElement == null ? null : getNodeForElement(disposedElement, false); if (node != null && isValidForSelectionAdjusting(node)) { Object newElement = getElementFor(node); addSelectionPath(getPathFor(node), true, getExpiredElementCondition(newElement), disposedElement); return; } if (selectedIndex >= 0) { if (parentNode.getChildCount() > 0) { if (parentNode.getChildCount() > selectedIndex) { TreeNode newChildNode = parentNode.getChildAt(selectedIndex); if (isValidForSelectionAdjusting(newChildNode)) { addSelectionPath(new TreePath(myTreeModel.getPathToRoot(newChildNode)), true, getExpiredElementCondition(disposedElement), disposedElement); } } else { TreeNode newChild = parentNode.getChildAt(parentNode.getChildCount() - 1); if (isValidForSelectionAdjusting(newChild)) { addSelectionPath(new TreePath(myTreeModel.getPathToRoot(newChild)), true, getExpiredElementCondition(disposedElement), disposedElement); } } } else { addSelectionPath(new TreePath(myTreeModel.getPathToRoot(parentNode)), true, getExpiredElementCondition(disposedElement), disposedElement); } } } | adjustSelectionOnChildRemove |
279,219 | boolean (@NotNull TreeNode node) { if (!myTree.isRootVisible() && getRootNode() == node) return false; if (isLoadingNode(node)) return true; Object elementInTree = getElementFor(node); if (elementInTree == null) return false; TreeNode parentNode = node.getParent(); Object parentElementInTree = getElementFor(parentNode); if (parentElementInTree == null) return false; Object parentElement = getTreeStructure().getParentElement(elementInTree); return parentElementInTree.equals(parentElement); } | isValidForSelectionAdjusting |
279,220 | void (@NotNull TreePath path, boolean isAdjustedSelection, Condition<?> isExpiredAdjustment, @Nullable Object adjustmentCause) { processInnerChange(new TreeRunnable("AbstractTreeUi.addSelectionPath") { @Override public void perform() { TreePath toSelect = null; if (isLoadingNode(path.getLastPathComponent())) { TreePath parentPath = path.getParentPath(); if (parentPath != null && isValidForSelectionAdjusting((TreeNode)parentPath.getLastPathComponent())) { toSelect = parentPath; } } else { toSelect = path; } if (toSelect != null) { mySelectionIsAdjusted = isAdjustedSelection; myTree.addSelectionPath(toSelect); if (isAdjustedSelection && myUpdaterState != null) { Object toSelectElement = getElementFor(toSelect.getLastPathComponent()); myUpdaterState.addAdjustedSelection(toSelectElement, isExpiredAdjustment, adjustmentCause); } } } }); } | addSelectionPath |
279,221 | void () { TreePath toSelect = null; if (isLoadingNode(path.getLastPathComponent())) { TreePath parentPath = path.getParentPath(); if (parentPath != null && isValidForSelectionAdjusting((TreeNode)parentPath.getLastPathComponent())) { toSelect = parentPath; } } else { toSelect = path; } if (toSelect != null) { mySelectionIsAdjusted = isAdjustedSelection; myTree.addSelectionPath(toSelect); if (isAdjustedSelection && myUpdaterState != null) { Object toSelectElement = getElementFor(toSelect.getLastPathComponent()); myUpdaterState.addAdjustedSelection(toSelectElement, isExpiredAdjustment, adjustmentCause); } } } | perform |
279,222 | TreePath (@NotNull TreeNode node) { if (node instanceof DefaultMutableTreeNode) { return new TreePath(((DefaultMutableTreeNode)node).getPath()); } else { List<TreeNode> nodes = new ArrayList<>(); TreeNode eachParent = node; while (eachParent != null) { nodes.add(eachParent); eachParent = eachParent.getParent(); } return new TreePath(ArrayUtil.toObjectArray(nodes)); } } | getPathFor |
279,223 | void (@NotNull MutableTreeNode node, boolean willAdjustSelection) { processInnerChange(new TreeRunnable("AbstractTreeUi.removeNodeFromParent") { @Override public void perform() { if (willAdjustSelection) { TreePath path = getPathFor(node); if (myTree.isPathSelected(path)) { myTree.removeSelectionPath(path); } } if (node.getParent() != null) { myTreeModel.removeNodeFromParent(node); } } }); } | removeNodeFromParent |
279,224 | void () { if (willAdjustSelection) { TreePath path = getPathFor(node); if (myTree.isPathSelected(path)) { myTree.removeSelectionPath(path); } } if (node.getParent() != null) { myTreeModel.removeNodeFromParent(node); } } | perform |
279,225 | void (@NotNull TreePath path, boolean canSmartExpand) { processInnerChange(new TreeRunnable("AbstractTreeUi.expandPath") { @Override public void perform() { if (path.getLastPathComponent() instanceof DefaultMutableTreeNode node) { if (node.getChildCount() > 0 && !myTree.isExpanded(path)) { if (!canSmartExpand) { myNotForSmartExpand.add(node); } try { myRequestedExpand = path; myTree.expandPath(path); processSmartExpand(node, canSmartExpand, false); } finally { myNotForSmartExpand.remove(node); myRequestedExpand = null; } } else { processNodeActionsIfReady(node); } } } }); } | expandPath |
279,226 | void () { if (path.getLastPathComponent() instanceof DefaultMutableTreeNode node) { if (node.getChildCount() > 0 && !myTree.isExpanded(path)) { if (!canSmartExpand) { myNotForSmartExpand.add(node); } try { myRequestedExpand = path; myTree.expandPath(path); processSmartExpand(node, canSmartExpand, false); } finally { myNotForSmartExpand.remove(node); myRequestedExpand = null; } } else { processNodeActionsIfReady(node); } } } | perform |
279,227 | void (Runnable runnable) { if (myUpdaterState == null) { setUpdaterState(new UpdaterTreeState(this)); } myUpdaterState.process(runnable); } | processInnerChange |
279,228 | boolean () { return myUpdaterState != null && myUpdaterState.isProcessingNow() && myUserRunnables.isEmpty(); } | isInnerChange |
279,229 | void (@NotNull DefaultMutableTreeNode node) { TreePath path = getPathFor(node); insertLoadingNode(node, true); NodeDescriptor<?> descriptor = getDescriptorFrom(node); if (descriptor == null) return; descriptor.setChildrenSortingStamp(-1); if (getBuilder().isAlwaysShowPlus(descriptor)) return; TreePath parentPath = path.getParentPath(); if (myTree.isVisible(path) || parentPath != null && myTree.isExpanded(parentPath)) { if (myTree.isExpanded(path)) { addSubtreeToUpdate(node); } else { insertLoadingNode(node, false); } } } | makeLoadingOrLeafIfNoChildren |
279,230 | boolean (NodeDescriptor<?> descriptor, NodeDescriptor<?> parent) { if (descriptor == null) return false; if (parent != null && parent != descriptor.getParentDescriptor()) return false; return isValid(getElementFromDescriptor(descriptor)); } | isValid |
279,231 | boolean (@Nullable NodeDescriptor<?> descriptor) { return descriptor != null && isValid(getElementFromDescriptor(descriptor)); } | isValid |
279,232 | boolean (Object element) { if (isNodeNull(element)) return false; if (element instanceof ValidateableNode) { if (!((ValidateableNode)element).isValid()) return false; } return getBuilder().validateNode(element); } | isValid |
279,233 | void (DefaultMutableTreeNode node, boolean addToUnbuilt) { if (!isLoadingChildrenFor(node)) { myTreeModel.insertNodeInto(new LoadingNode(), node, 0); } if (addToUnbuilt) { addToUnbuilt(node); } } | insertLoadingNode |
279,234 | Promise<Void> (@NotNull Runnable bgBuildAction, @Nullable Runnable edtPostRunnable) { if (!canInitiateNewActivity()) return Promises.rejectedPromise(); AsyncPromise<Void> result = new AsyncPromise<>(); AtomicReference<ProcessCanceledException> fail = new AtomicReference<>(); Runnable finalizer = new TreeRunnable("AbstractTreeUi.queueToBackground: finalizer") { @Override public void perform() { ProcessCanceledException exception = fail.get(); if (exception == null) { result.setResult(null); } else { result.setError(exception); } } }; registerWorkerTask(bgBuildAction); Runnable pooledThreadWithProgressRunnable = new TreeRunnable("AbstractTreeUi.queueToBackground: progress") { @Override public void perform() { try { AbstractTreeBuilder builder = getBuilder(); if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } builder.runBackgroundLoading(new TreeRunnable("AbstractTreeUi.queueToBackground: background") { @Override public void perform() { assertNotDispatchThread(); try { if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } execute(bgBuildAction); if (edtPostRunnable != null) { builder.updateAfterLoadedInBackground(new TreeRunnable("AbstractTreeUi.queueToBackground: update after") { @Override public void perform() { try { assertIsDispatchThread(); if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } execute(edtPostRunnable); } catch (ProcessCanceledException e) { fail.set(e); cancelUpdate(); } finally { unregisterWorkerTask(bgBuildAction, finalizer); } } }); } else { unregisterWorkerTask(bgBuildAction, finalizer); } } catch (ProcessCanceledException e) { fail.set(e); unregisterWorkerTask(bgBuildAction, finalizer); cancelUpdate(); } catch (Throwable t) { unregisterWorkerTask(bgBuildAction, finalizer); throw new RuntimeException(t); } } }); } catch (ProcessCanceledException e) { unregisterWorkerTask(bgBuildAction, finalizer); cancelUpdate(); } } }; Runnable pooledThreadRunnable = new TreeRunnable("AbstractTreeUi.queueToBackground") { @Override public void perform() { try { if (myProgress != null && ProgressIndicatorProvider.getGlobalProgressIndicator() != myProgress) { ProgressManager.getInstance().runProcess(pooledThreadWithProgressRunnable, myProgress); } else { execute(pooledThreadWithProgressRunnable); } } catch (ProcessCanceledException e) { fail.set(e); unregisterWorkerTask(bgBuildAction, finalizer); cancelUpdate(); } } }; if (isPassthroughMode()) { execute(pooledThreadRunnable); } else { myWorker.addFirst(pooledThreadRunnable); } return result; } | queueToBackground |
279,235 | void () { ProcessCanceledException exception = fail.get(); if (exception == null) { result.setResult(null); } else { result.setError(exception); } } | perform |
279,236 | void () { try { AbstractTreeBuilder builder = getBuilder(); if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } builder.runBackgroundLoading(new TreeRunnable("AbstractTreeUi.queueToBackground: background") { @Override public void perform() { assertNotDispatchThread(); try { if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } execute(bgBuildAction); if (edtPostRunnable != null) { builder.updateAfterLoadedInBackground(new TreeRunnable("AbstractTreeUi.queueToBackground: update after") { @Override public void perform() { try { assertIsDispatchThread(); if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } execute(edtPostRunnable); } catch (ProcessCanceledException e) { fail.set(e); cancelUpdate(); } finally { unregisterWorkerTask(bgBuildAction, finalizer); } } }); } else { unregisterWorkerTask(bgBuildAction, finalizer); } } catch (ProcessCanceledException e) { fail.set(e); unregisterWorkerTask(bgBuildAction, finalizer); cancelUpdate(); } catch (Throwable t) { unregisterWorkerTask(bgBuildAction, finalizer); throw new RuntimeException(t); } } }); } catch (ProcessCanceledException e) { unregisterWorkerTask(bgBuildAction, finalizer); cancelUpdate(); } } | perform |
279,237 | void () { assertNotDispatchThread(); try { if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } execute(bgBuildAction); if (edtPostRunnable != null) { builder.updateAfterLoadedInBackground(new TreeRunnable("AbstractTreeUi.queueToBackground: update after") { @Override public void perform() { try { assertIsDispatchThread(); if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } execute(edtPostRunnable); } catch (ProcessCanceledException e) { fail.set(e); cancelUpdate(); } finally { unregisterWorkerTask(bgBuildAction, finalizer); } } }); } else { unregisterWorkerTask(bgBuildAction, finalizer); } } catch (ProcessCanceledException e) { fail.set(e); unregisterWorkerTask(bgBuildAction, finalizer); cancelUpdate(); } catch (Throwable t) { unregisterWorkerTask(bgBuildAction, finalizer); throw new RuntimeException(t); } } | perform |
279,238 | void () { try { assertIsDispatchThread(); if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } execute(edtPostRunnable); } catch (ProcessCanceledException e) { fail.set(e); cancelUpdate(); } finally { unregisterWorkerTask(bgBuildAction, finalizer); } } | perform |
279,239 | void () { try { if (myProgress != null && ProgressIndicatorProvider.getGlobalProgressIndicator() != myProgress) { ProgressManager.getInstance().runProcess(pooledThreadWithProgressRunnable, myProgress); } else { execute(pooledThreadWithProgressRunnable); } } catch (ProcessCanceledException e) { fail.set(e); unregisterWorkerTask(bgBuildAction, finalizer); cancelUpdate(); } } | perform |
279,240 | void (@NotNull Runnable runnable) { synchronized (myActiveWorkerTasks) { myActiveWorkerTasks.add(runnable); } } | registerWorkerTask |
279,241 | void (@NotNull Runnable runnable, @Nullable Runnable finalizeRunnable) { boolean wasRemoved; synchronized (myActiveWorkerTasks) { wasRemoved = myActiveWorkerTasks.remove(runnable); } if (wasRemoved && finalizeRunnable != null) { finalizeRunnable.run(); } invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.unregisterWorkerTask") { @Override public void perform() { maybeReady(); } }); } | unregisterWorkerTask |
279,242 | void () { maybeReady(); } | perform |
279,243 | boolean () { synchronized (myActiveWorkerTasks) { return !myActiveWorkerTasks.isEmpty(); } } | isWorkerBusy |
279,244 | void () { synchronized (myActiveWorkerTasks) { myActiveWorkerTasks.clear(); } } | clearWorkerTasks |
279,245 | void (@NotNull DefaultMutableTreeNode node) { NodeDescriptor<?> descriptor = getDescriptorFrom(node); if (descriptor == null) return; if (getElementFromDescriptor(descriptor) == null) return; nodeChanged(node); } | updateNodeImageAndPosition |
279,246 | void (DefaultMutableTreeNode node) { invokeLaterIfNeeded(true, new TreeRunnable("AbstractTreeUi.nodeChanged") { @Override public void perform() { myTreeModel.nodeChanged(node); } }); } | nodeChanged |
279,247 | void () { myTreeModel.nodeChanged(node); } | perform |
279,248 | void (DefaultMutableTreeNode node) { invokeLaterIfNeeded(true, new TreeRunnable("AbstractTreeUi.nodeStructureChanged") { @Override public void perform() { myTreeModel.nodeStructureChanged(node); } }); } | nodeStructureChanged |
279,249 | void () { myTreeModel.nodeStructureChanged(node); } | perform |
279,250 | DefaultTreeModel () { return myTreeModel; } | getTreeModel |
279,251 | void (@NotNull List<? extends TreeNode> toInsert, @NotNull DefaultMutableTreeNode parentNode) { sortChildren(parentNode, toInsert, false, true); List<TreeNode> all = new ArrayList<>(toInsert.size() + parentNode.getChildCount()); all.addAll(toInsert); all.addAll(TreeUtil.listChildren(parentNode)); if (!toInsert.isEmpty()) { sortChildren(parentNode, all, true, true); int[] newNodeIndices = new int[toInsert.size()]; int eachNewNodeIndex = 0; TreeMap<Integer, TreeNode> insertSet = new TreeMap<>(); for (int i = 0; i < toInsert.size(); i++) { TreeNode eachNewNode = toInsert.get(i); while (all.get(eachNewNodeIndex) != eachNewNode) { eachNewNodeIndex++; } newNodeIndices[i] = eachNewNodeIndex; insertSet.put(eachNewNodeIndex, eachNewNode); } for (Map.Entry<Integer, TreeNode> entry : insertSet.entrySet()) { TreeNode eachNode = entry.getValue(); Integer index = entry.getKey(); parentNode.insert((MutableTreeNode)eachNode, index); } myTreeModel.nodesWereInserted(parentNode, newNodeIndices); } else { List<TreeNode> before = new ArrayList<>(all); sortChildren(parentNode, all, true, false); if (!before.equals(all)) { processInnerChange(new TreeRunnable("AbstractTreeUi.insertNodesInto") { @Override public void perform() { Enumeration<TreePath> expanded = getTree().getExpandedDescendants(getPathFor(parentNode)); TreePath[] selected = getTree().getSelectionModel().getSelectionPaths(); parentNode.removeAllChildren(); for (TreeNode each : all) { parentNode.add((MutableTreeNode)each); } nodeStructureChanged(parentNode); if (expanded != null) { while (expanded.hasMoreElements()) { expandSilently(expanded.nextElement()); } } if (selected != null) { for (TreePath each : selected) { if (!getTree().getSelectionModel().isPathSelected(each)) { addSelectionSilently(each); } } } } }); } } } | insertNodesInto |
279,252 | void () { Enumeration<TreePath> expanded = getTree().getExpandedDescendants(getPathFor(parentNode)); TreePath[] selected = getTree().getSelectionModel().getSelectionPaths(); parentNode.removeAllChildren(); for (TreeNode each : all) { parentNode.add((MutableTreeNode)each); } nodeStructureChanged(parentNode); if (expanded != null) { while (expanded.hasMoreElements()) { expandSilently(expanded.nextElement()); } } if (selected != null) { for (TreePath each : selected) { if (!getTree().getSelectionModel().isPathSelected(each)) { addSelectionSilently(each); } } } } | perform |
279,253 | void (@NotNull DefaultMutableTreeNode node, @NotNull List<? extends TreeNode> children, boolean updateStamp, boolean forceSort) { NodeDescriptor<?> descriptor = getDescriptorFrom(node); assert descriptor != null; if (descriptor.getChildrenSortingStamp() >= getComparatorStamp() && !forceSort) return; if (!children.isEmpty()) { try { getBuilder().sortChildren(myNodeComparator, node, children); } catch (IllegalArgumentException exception) { StringBuilder sb = new StringBuilder("cannot sort children in ").append(this); children.forEach(child -> sb.append('\n').append(child)); throw new IllegalArgumentException(sb.toString(), exception); } } if (updateStamp) { descriptor.setChildrenSortingStamp(getComparatorStamp()); } } | sortChildren |
279,254 | void (@NotNull DefaultMutableTreeNode node) { TreeNode parent = node.getParent(); if (parent instanceof DefaultMutableTreeNode) { addToUnbuilt((DefaultMutableTreeNode)parent); } if (node.getChildCount() > 0) { for (DefaultMutableTreeNode _node = (DefaultMutableTreeNode)node.getFirstChild(); _node != null; _node = _node.getNextSibling()) { disposeNode(_node); } } removeFromUpdatingChildren(node); removeFromUnbuilt(node); removeFromCancelled(node); if (isLoadingNode(node)) return; NodeDescriptor<?> descriptor = getDescriptorFrom(node); if (descriptor == null) return; Object element = getElementFromDescriptor(descriptor); if (!isNodeNull(element)) { removeMapping(element, node, null); } myAutoExpandRoots.remove(element); node.setUserObject(null); node.removeAllChildren(); } | disposeNode |
279,255 | boolean (@NotNull DefaultMutableTreeNode root) { return addSubtreeToUpdate(root, true); } | addSubtreeToUpdate |
279,256 | boolean (@NotNull DefaultMutableTreeNode root, boolean updateStructure) { return addSubtreeToUpdate(root, null, updateStructure); } | addSubtreeToUpdate |
279,257 | boolean (@NotNull DefaultMutableTreeNode root, Runnable runAfterUpdate) { return addSubtreeToUpdate(root, runAfterUpdate, true); } | addSubtreeToUpdate |
279,258 | boolean (@NotNull DefaultMutableTreeNode root, @Nullable Runnable runAfterUpdate, boolean updateStructure) { Object element = getElementFor(root); boolean alwaysLeaf = element != null && getTreeStructure().isAlwaysLeaf(element); TreeUpdatePass updatePass; if (alwaysLeaf) { removeFromUnbuilt(root); removeLoading(root, true); updatePass = new TreeUpdatePass(root).setUpdateChildren(false); } else { updatePass = new TreeUpdatePass(root).setUpdateStructure(updateStructure).setUpdateStamp(-1); } AbstractTreeUpdater updater = getUpdater(); updater.runAfterUpdate(runAfterUpdate); updater.addSubtreeToUpdate(updatePass); return !alwaysLeaf; } | addSubtreeToUpdate |
279,259 | void (Object @NotNull [] elements, @Nullable Runnable onDone) { select(elements, onDone, false); } | select |
279,260 | void (Object @NotNull [] elements, @Nullable Runnable onDone, boolean addToSelection) { select(elements, onDone, addToSelection, false); } | select |
279,261 | void (Object @NotNull [] elements, @Nullable Runnable onDone, boolean addToSelection, boolean deferred) { _select(elements, onDone, addToSelection, true, false, true, deferred, false, false); } | select |
279,262 | void (Object @NotNull [] elements, Runnable onDone, boolean addToSelection, boolean scroll) { _select(elements, onDone, addToSelection, true, false, scroll, false, true, true); } | userSelect |
279,263 | void () { myCanProcessDeferredSelections = false; } | perform |
279,264 | void () { try { if (!checkDeferred(deferred, onDone)) return; Set<Object> currentElements = getSelectedElements(); if (checkCurrentSelection && !currentElements.isEmpty() && elements.length == currentElements.size()) { boolean runSelection = false; for (Object eachToSelect : elements) { if (!currentElements.contains(eachToSelect)) { runSelection = true; break; } } if (!runSelection) { selectVisible(elements[0], onDone, false, false, scrollToVisible); return; } } clearSelection(); Set<Object> toSelect = new HashSet<>(); ContainerUtil.addAllNotNull(toSelect, elements); if (addToSelection) { ContainerUtil.addAllNotNull(toSelect, currentElements); } if (checkIfInStructure) { toSelect.removeIf(each -> !isInStructure(each)); } Object[] elementsToSelect = ArrayUtil.toObjectArray(toSelect); if (wasRootNodeInitialized()) { int[] originalRows = myTree.getSelectionRows(); if (!addToSelection) { clearSelection(); } addNext(elementsToSelect, 0, new TreeRunnable("AbstractTreeUi._select: addNext") { @Override public void perform() { if (getTree().isSelectionEmpty()) { processInnerChange(new TreeRunnable("AbstractTreeUi._select: addNext: processInnerChange") { @Override public void perform() { restoreSelection(currentElements); } }); } runDone(onDone); } }, originalRows, deferred, scrollToVisible, canSmartExpand); } else { addToDeferred(elementsToSelect, onDone, addToSelection); } } finally { maybeReady(); } } | perform |
279,265 | void () { if (getTree().isSelectionEmpty()) { processInnerChange(new TreeRunnable("AbstractTreeUi._select: addNext: processInnerChange") { @Override public void perform() { restoreSelection(currentElements); } }); } runDone(onDone); } | perform |
279,266 | void () { restoreSelection(currentElements); } | perform |
279,267 | void () { mySelectionIsBeingAdjusted = true; try { myTree.clearSelection(); } finally { mySelectionIsBeingAdjusted = false; } } | clearSelection |
279,268 | void (@NotNull Set<Object> selection) { for (Object each : selection) { DefaultMutableTreeNode node = getNodeForElement(each, false); if (node != null && isValidForSelectionAdjusting(node)) { addSelectionPath(getPathFor(node), false, null, null); } } } | restoreSelection |
279,269 | void (Object @NotNull [] elementsToSelect, Runnable onDone, boolean addToSelection) { if (!addToSelection) { myDeferredSelections.clear(); } myDeferredSelections.add(new TreeRunnable("AbstractTreeUi.addToDeferred") { @Override public void perform() { select(elementsToSelect, onDone, addToSelection, true); } }); } | addToDeferred |
279,270 | void () { select(elementsToSelect, onDone, addToSelection, true); } | perform |
279,271 | boolean (boolean isDeferred, @Nullable Runnable onDone) { if (!isDeferred || myCanProcessDeferredSelections || !wasRootNodeInitialized()) { return true; } else { runDone(onDone); return false; } } | checkDeferred |
279,272 | Set<Object> () { TreePath[] paths = myTree.getSelectionPaths(); Set<Object> result = new LinkedHashSet<>(); if (paths != null) { for (TreePath eachPath : paths) { if (eachPath.getLastPathComponent() instanceof DefaultMutableTreeNode eachNode) { if (eachNode == myRootNode && !myTree.isRootVisible()) continue; Object eachElement = getElementFor(eachNode); if (eachElement != null) { result.add(eachElement); } } } } return result; } | getSelectedElements |
279,273 | void (Object @NotNull [] elements, int i, @Nullable Runnable onDone, int[] originalRows, boolean deferred, boolean scrollToVisible, boolean canSmartExpand) { if (i >= elements.length) { if (myTree.isSelectionEmpty()) { myTree.setSelectionRows(originalRows); } runDone(onDone); } else { if (!checkDeferred(deferred, onDone)) { return; } doSelect(elements[i], new TreeRunnable("AbstractTreeUi.addNext") { @Override public void perform() { if (!checkDeferred(deferred, onDone)) return; addNext(elements, i + 1, onDone, originalRows, deferred, scrollToVisible, canSmartExpand); } }, deferred, i == 0, scrollToVisible, canSmartExpand); } } | addNext |
279,274 | void () { if (!checkDeferred(deferred, onDone)) return; addNext(elements, i + 1, onDone, originalRows, deferred, scrollToVisible, canSmartExpand); } | perform |
279,275 | void (@Nullable Object element, @Nullable Runnable onDone) { select(element, onDone, false); } | select |
279,276 | void (@Nullable Object element, @Nullable Runnable onDone, boolean addToSelection) { if (element == null) return; _select(new Object[]{element}, onDone, addToSelection, false); } | select |
279,277 | void (@NotNull Object element, Runnable onDone, boolean deferred, boolean canBeCentered, boolean scrollToVisible, boolean canSmartExpand) { Runnable _onDone = new TreeRunnable("AbstractTreeUi.doSelect") { @Override public void perform() { if (!checkDeferred(deferred, onDone)) return; checkPathAndMaybeRevalidate(element, new TreeRunnable("AbstractTreeUi.doSelect: checkPathAndMaybeRevalidate") { @Override public void perform() { selectVisible(element, onDone, true, canBeCentered, scrollToVisible); } }, true, canSmartExpand); } }; _expand(element, _onDone, true, false, canSmartExpand); } | doSelect |
279,278 | void () { if (!checkDeferred(deferred, onDone)) return; checkPathAndMaybeRevalidate(element, new TreeRunnable("AbstractTreeUi.doSelect: checkPathAndMaybeRevalidate") { @Override public void perform() { selectVisible(element, onDone, true, canBeCentered, scrollToVisible); } }, true, canSmartExpand); } | perform |
279,279 | void () { selectVisible(element, onDone, true, canBeCentered, scrollToVisible); } | perform |
279,280 | void (@NotNull Object element, @NotNull Runnable onDone, boolean parentsOnly, boolean canSmartExpand) { boolean toRevalidate = isValid(element) && !myRevalidatedObjects.contains(element) && getNodeForElement(element, false) == null && isInStructure(element); if (!toRevalidate) { runDone(onDone); return; } myRevalidatedObjects.add(element); getBuilder() .revalidateElement(element) .onSuccess(o -> invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.checkPathAndMaybeRevalidate: on done revalidateElement") { @Override public void perform() { _expand(o, onDone, parentsOnly, false, canSmartExpand); } })) .onError(throwable -> wrapDone(onDone, "AbstractTreeUi.checkPathAndMaybeRevalidate: on rejected revalidateElement").run()); } | checkPathAndMaybeRevalidate |
279,281 | void () { _expand(o, onDone, parentsOnly, false, canSmartExpand); } | perform |
279,282 | void (@Nullable Runnable onDone, boolean shouldBeCentered) { SwingUtilities.invokeLater(new TreeRunnable("AbstractTreeUi.scrollSelectionToVisible") { @Override public void perform() { if (isReleased()) return; int[] rows = myTree.getSelectionRows(); if (rows == null || rows.length == 0) { runDone(onDone); return; } Object toSelect = null; for (int eachRow : rows) { TreePath path = myTree.getPathForRow(eachRow); toSelect = getElementFor(path.getLastPathComponent()); if (toSelect != null) break; } if (toSelect != null) { selectVisible(toSelect, onDone, true, shouldBeCentered, true); } } }); } | scrollSelectionToVisible |
279,283 | void () { if (isReleased()) return; int[] rows = myTree.getSelectionRows(); if (rows == null || rows.length == 0) { runDone(onDone); return; } Object toSelect = null; for (int eachRow : rows) { TreePath path = myTree.getPathForRow(eachRow); toSelect = getElementFor(path.getLastPathComponent()); if (toSelect != null) break; } if (toSelect != null) { selectVisible(toSelect, onDone, true, shouldBeCentered, true); } } | perform |
279,284 | void (@NotNull Object element, Runnable onDone, boolean addToSelection, boolean canBeCentered, boolean scroll) { DefaultMutableTreeNode toSelect = getNodeToScroll(element); if (toSelect == null) { runDone(onDone); return; } if (myUpdaterState != null) { myUpdaterState.addSelection(element); } setHoldSize(false); runDone(wrapScrollTo(onDone, element, toSelect, addToSelection, canBeCentered, scroll)); } | selectVisible |
279,285 | DefaultMutableTreeNode (Object element) { if (element == null) return null; DefaultMutableTreeNode node = getNodeForElement(element, false); if (node == null) return null; return myTree.isRootVisible() || node != getRootNode() ? node : null; } | getNodeToScroll |
279,286 | Runnable (Runnable onDone, @NotNull String name) { return new TreeRunnable(name) { @Override public void perform() { runDone(onDone); } }; } | wrapDone |
279,287 | void () { runDone(onDone); } | perform |
279,288 | Runnable (Runnable onDone, @NotNull Object element, @NotNull 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")); } }; } | wrapScrollTo |
279,289 | void () { 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")); } | perform |
279,290 | int (@NotNull Object element) { Set<Object> selection = getSelectedElements(); if (selection.contains(element)) { TreePath[] paths = getTree().getSelectionPaths(); for (TreePath each : paths) { if (element.equals(getElementFor(each.getLastPathComponent()))) { return getTree().getRowForPath(each); } } return -1; } Object anchor = TreeAnchorizer.getService().createAnchor(element); Object o = isNodeNull(anchor) ? null : myElementToNodeMap.get(anchor); TreeAnchorizer.getService().freeAnchor(anchor); if (o instanceof List) { TreePath[] paths = getTree().getSelectionPaths(); if (paths != null && paths.length > 0) { Set<DefaultMutableTreeNode> selectedNodes = new HashSet<>(); for (TreePath eachPAth : paths) { if (eachPAth.getLastPathComponent() instanceof DefaultMutableTreeNode) { selectedNodes.add((DefaultMutableTreeNode)eachPAth.getLastPathComponent()); } } //noinspection unchecked for (DefaultMutableTreeNode eachNode : (List<DefaultMutableTreeNode>)o) { while (eachNode != null) { if (selectedNodes.contains(eachNode)) { return getTree().getRowForPath(getPathFor(eachNode)); } eachNode = (DefaultMutableTreeNode)eachNode.getParent(); } } } } return -1; } | getRowIfUnderSelection |
279,291 | void (@Nullable Runnable onDone) { JTree tree = getTree(); if (tree.getRowCount() > 0) { int expandRecursionDepth = Math.max(2, Registry.intValue("ide.tree.expandRecursionDepth")); new TreeRunnable("AbstractTreeUi.expandAll") { private int myCurrentRow; private int myInvocationCount; @Override public void perform() { if (++myInvocationCount > expandRecursionDepth) { myInvocationCount = 0; if (isPassthroughMode()) { run(); } else { // need this to prevent stack overflow if the tree is rather big and is "synchronous" SwingUtilities.invokeLater(this); } } else { int row = myCurrentRow++; if (row < tree.getRowCount()) { TreePath path = tree.getPathForRow(row); Object last = path.getLastPathComponent(); Object elem = getElementFor(last); expand(elem, this); } else { runDone(onDone); } } } }.run(); } else { runDone(onDone); } } | expandAll |
279,292 | void () { if (++myInvocationCount > expandRecursionDepth) { myInvocationCount = 0; if (isPassthroughMode()) { run(); } else { // need this to prevent stack overflow if the tree is rather big and is "synchronous" SwingUtilities.invokeLater(this); } } else { int row = myCurrentRow++; if (row < tree.getRowCount()) { TreePath path = tree.getPathForRow(row); Object last = path.getLastPathComponent(); Object elem = getElementFor(last); expand(elem, this); } else { runDone(onDone); } } } | perform |
279,293 | void (Object element, @Nullable Runnable onDone) { expand(new Object[]{element}, onDone); } | expand |
279,294 | void (Object @NotNull [] element, @Nullable Runnable onDone) { expand(element, onDone, false); } | expand |
279,295 | void (Object @NotNull [] elements, @NotNull Runnable onDone, boolean checkIfInStructure) { try { runDone(new TreeRunnable("AbstractTreeUi._expand") { @Override public void perform() { if (elements.length == 0) { runDone(onDone); return; } if (myUpdaterState != null) { myUpdaterState.clearExpansion(); } ActionCallback done = new ActionCallback(elements.length); done .doWhenDone(wrapDone(onDone, "AbstractTreeUi._expand: on done expandNext")) .doWhenRejected(wrapDone(onDone, "AbstractTreeUi._expand: on rejected expandNext")); expandNext(elements, 0, false, checkIfInStructure, false, done, 0); } }); } catch (ProcessCanceledException e) { try { runDone(onDone); } catch (ProcessCanceledException ignored) { //todo added to fix IDEA-58475 } } } | _expand |
279,296 | void () { if (elements.length == 0) { runDone(onDone); return; } if (myUpdaterState != null) { myUpdaterState.clearExpansion(); } ActionCallback done = new ActionCallback(elements.length); done .doWhenDone(wrapDone(onDone, "AbstractTreeUi._expand: on done expandNext")) .doWhenRejected(wrapDone(onDone, "AbstractTreeUi._expand: on rejected expandNext")); expandNext(elements, 0, false, checkIfInStructure, false, done, 0); } | perform |
279,297 | void (Object @NotNull [] elements, int index, boolean parentsOnly, boolean checkIfInStricture, boolean canSmartExpand, @NotNull ActionCallback done, int currentDepth) { if (elements.length <= 0) { done.setDone(); return; } if (index >= elements.length) { return; } int[] actualDepth = {currentDepth}; boolean breakCallChain = false; if (actualDepth[0] > Registry.intValue("ide.tree.expandRecursionDepth")) { actualDepth[0] = 0; breakCallChain = true; } Runnable expandRunnable = new TreeRunnable("AbstractTreeUi.expandNext") { @Override public void perform() { _expand(elements[index], new TreeRunnable("AbstractTreeUi.expandNext: on done") { @Override public void perform() { done.setDone(); expandNext(elements, index + 1, parentsOnly, checkIfInStricture, canSmartExpand, done, actualDepth[0] + 1); } }, parentsOnly, checkIfInStricture, canSmartExpand); } }; if (breakCallChain && !isPassthroughMode()) { SwingUtilities.invokeLater(expandRunnable); } else { expandRunnable.run(); } } | expandNext |
279,298 | void () { _expand(elements[index], new TreeRunnable("AbstractTreeUi.expandNext: on done") { @Override public void perform() { done.setDone(); expandNext(elements, index + 1, parentsOnly, checkIfInStricture, canSmartExpand, done, actualDepth[0] + 1); } }, parentsOnly, checkIfInStricture, canSmartExpand); } | perform |
279,299 | void () { done.setDone(); expandNext(elements, index + 1, parentsOnly, checkIfInStricture, canSmartExpand, done, actualDepth[0] + 1); } | perform |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.