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 (loade... | 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 (n... | 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()... | 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; } removeFromLoaded... | 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)) { real... | 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); bool... | 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 = secondaryNo... | 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 && valida... | 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(no... | 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.g... | 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 != nul... | 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(no... | 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)... | 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... | 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) { mySelectio... | 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(); } retur... | 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 (nod... | 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) { myNotF... | 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 { my... | 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... | 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("Abstr... | 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 (!canInitiateNewActiv... | 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 { as... | 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); unregisterWo... | 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.unreg... | 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(... | 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 (expande... | 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.isEmp... | 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... | 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, t... | 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(ea... | 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 eac... | 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, onDon... | 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... | 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; } myRevalidated... | 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; } Obj... | 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) br... | 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); runDon... | 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.get... | 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 / ... | 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; } Objec... | 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() { i... | 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()) { TreeP... | 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 d... | _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._... | 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 breakCallCh... | 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.