Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
279,000 | void () { AbstractTreeUi ui = getUi(); if (ui != null) ui.requestRelease(); } | dispose |
279,001 | boolean (@NotNull NodeDescriptor descriptor) { AbstractTreeUi ui = getUi(); return ui != null && descriptor.update(); } | updateNodeDescriptor |
279,002 | Set<Object> () { AbstractTreeUi ui = getUi(); return ui == null ? Collections.emptySet() : ui.getSelectedElements(); } | getSelectedElements |
279,003 | Object (Object object) { return object; } | transformElement |
279,004 | void (boolean yield) { AbstractTreeUi ui = getUi(); if (ui != null) ui.setCanYield(yield); } | setCanYieldUpdate |
279,005 | void (@Nullable Runnable onDone, boolean shouldBeCentered) { AbstractTreeUi ui = getUi(); if (ui != null) ui.scrollSelectionToVisible(onDone, shouldBeCentered); } | scrollSelectionToVisible |
279,006 | boolean () { Application app = ApplicationManager.getApplication(); return app != null && app.isUnitTestMode(); } | isUnitTestingMode |
279,007 | boolean (@NotNull JTree tree) { AbstractTreeBuilder builder = getBuilderFor(tree); return builder == null || builder.getUi() == null || builder.getUi().isToPaintSelection(); } | isToPaintSelection |
279,008 | void () { if (myRunnable != null) { AbstractTreeUi ui = getUi(); if (ui != null) { ui.executeUserRunnable(myRunnable); } else { myRunnable.run(); } } } | run |
279,009 | boolean () { AbstractTreeUi ui = getUi(); return ui != null && ui.isSelectionBeingAdjusted(); } | isSelectionBeingAdjusted |
279,010 | boolean (Object element) { AbstractTreeUi ui = getUi(); return ui != null && ui.isToBuildChildrenInBackground(element); } | isToBuildChildrenInBackground |
279,011 | boolean () { AbstractTreeUi ui = getUi(); return ui != null && ui.isConsistent(); } | isConsistent |
279,012 | void (int delay) { myUpdateQueue.setMergingTimeSpan(delay); } | setDelay |
279,013 | ModalityState () { return myUpdateQueue.getModalityState(); } | getModalityState |
279,014 | boolean () { return !myNodeQueue.isEmpty() || !myUpdateQueue.isEmpty(); } | hasNodesToUpdate |
279,015 | void () { } | dispose |
279,016 | void () { if (myUpdateQueue.isEmpty() && !myNodeQueue.isEmpty()) { reQueueViewUpdate(); } } | reQueueViewUpdateIfNeeded |
279,017 | void () { queue(new Update("ViewUpdate") { @Override public boolean isExpired() { return myTreeBuilder.isDisposed(); } @Override public void run() { AbstractTreeStructure structure = myTreeBuilder.getTreeStructure(); if (structure.hasSomethingToCommit()) { structure.asyncCommit().doWhenDone(new TreeRunnable("AbstractTreeUpdater.reQueueViewUpdate") { @Override public void perform() { reQueueViewUpdateIfNeeded(); } }); return; } try { performUpdate(); } catch (ProcessCanceledException e) { throw e; } catch (RuntimeException e) { LOG.error(myTreeBuilder.getClass().getName(), e); } } }); } | reQueueViewUpdate |
279,018 | boolean () { return myTreeBuilder.isDisposed(); } | isExpired |
279,019 | void () { AbstractTreeStructure structure = myTreeBuilder.getTreeStructure(); if (structure.hasSomethingToCommit()) { structure.asyncCommit().doWhenDone(new TreeRunnable("AbstractTreeUpdater.reQueueViewUpdate") { @Override public void perform() { reQueueViewUpdateIfNeeded(); } }); return; } try { performUpdate(); } catch (ProcessCanceledException e) { throw e; } catch (RuntimeException e) { LOG.error(myTreeBuilder.getClass().getName(), e); } } | run |
279,020 | void () { reQueueViewUpdateIfNeeded(); } | perform |
279,021 | void (@NotNull Update update) { if (isReleased()) return; myUpdateQueue.queue(update); } | queue |
279,022 | void () { try { AbstractTreeUi ui = myTreeBuilder.getUi(); if (ui != null) ui.updateSubtreeNow(eachPass, false); } catch (ProcessCanceledException ignored) { } } | perform |
279,023 | void () { final Runnable runnable = new TreeRunnable("AbstractTreeUpdater.maybeRunAfterUpdate") { @Override public void perform() { List<Runnable> runAfterUpdate = null; synchronized (myRunAfterUpdate) { if (!myRunAfterUpdate.isEmpty()) { runAfterUpdate = new ArrayList<>(myRunAfterUpdate); myRunAfterUpdate.clear(); } } if (runAfterUpdate != null) { for (Runnable r : runAfterUpdate) { r.run(); } } } }; myTreeBuilder.getReady(this).doWhenDone(runnable); } | maybeRunAfterUpdate |
279,024 | void () { List<Runnable> runAfterUpdate = null; synchronized (myRunAfterUpdate) { if (!myRunAfterUpdate.isEmpty()) { runAfterUpdate = new ArrayList<>(myRunAfterUpdate); myRunAfterUpdate.clear(); } } if (runAfterUpdate != null) { for (Runnable r : runAfterUpdate) { r.run(); } } } | perform |
279,025 | boolean () { return myTreeBuilder.getUi() == null; } | isReleased |
279,026 | ActionCallback (TreeUpdatePass pass) { return ActionCallback.DONE; } | beforeUpdate |
279,027 | boolean (@NotNull Object element) { DefaultMutableTreeNode node = myTreeBuilder.getNodeForElement(element); if (node != null) { myTreeBuilder.queueUpdateFrom(element, false); return true; } else { return false; } } | addSubtreeToUpdateByElement |
279,028 | void (final Runnable runnable) { if (runnable != null) { synchronized (myRunAfterUpdate) { myRunAfterUpdate.add(runnable); } } } | runAfterUpdate |
279,029 | void () { myUpdateQueue.showNotify(); } | showNotify |
279,030 | void () { myUpdateQueue.hideNotify(); } | hideNotify |
279,031 | void () { myUpdateQueue.sendFlush(); } | flush |
279,032 | void (final SelectionRequest request) { queue(new Update("UserSelection", Update.LOW_PRIORITY) { @Override public void run() { AbstractTreeUi ui = myTreeBuilder.getUi(); if (ui != null) { request.execute(ui); } } @Override public boolean isExpired() { return myTreeBuilder.isDisposed(); } @Override public void setRejected() { request.reject(); } }); } | queueSelection |
279,033 | void () { AbstractTreeUi ui = myTreeBuilder.getUi(); if (ui != null) { request.execute(ui); } } | run |
279,034 | boolean () { return myTreeBuilder.isDisposed(); } | isExpired |
279,035 | void () { request.reject(); } | setRejected |
279,036 | void () { TreeUpdatePass[] passes; synchronized (this) { passes = myNodeQueue.toArray(new TreeUpdatePass[0]); myNodeQueue.clear(); } myUpdateQueue.cancelAllUpdates(); AbstractTreeUi ui = myTreeBuilder.getUi(); if (ui != null) { for (TreeUpdatePass each : passes) { ui.addToCancelled(each.getNode()); } } } | reset |
279,037 | void () { trace("started"); try { perform(); } finally { trace("finished"); } } | run |
279,038 | void (T t) { run(); } | accept |
279,039 | int (TreeNode n1, TreeNode n2) { if (isLoadingNode(n1) && isLoadingNode(n2)) return 0; if (isLoadingNode(n1)) return -1; if (isLoadingNode(n2)) return 1; NodeDescriptor<?> nodeDescriptor1 = getDescriptorFrom(n1); NodeDescriptor<?> nodeDescriptor2 = getDescriptorFrom(n2); if (nodeDescriptor1 == null && nodeDescriptor2 == null) return 0; if (nodeDescriptor1 == null) return -1; if (nodeDescriptor2 == null) return 1; return myNodeDescriptorComparator != null ? myNodeDescriptorComparator.compare(nodeDescriptor1, nodeDescriptor2) : Integer.compare(nodeDescriptor1.getIndex(), nodeDescriptor2.getIndex()); } | compare |
279,040 | void () { maybeSetBusyAndScheduleWaiterForReady(false, null); } | perform |
279,041 | void (FocusEvent e) { maybeReady(); } | focusGained |
279,042 | boolean () { return AbstractTreeUi.this.isReady(true); } | isReady |
279,043 | void () { removeActivity(); } | onReadyWasSent |
279,044 | String () { return "AbstractTreeUi: builder = " + myBuilder; } | toString |
279,045 | void (@NotNull AbstractTreeBuilder builder, @NotNull JTree tree, @NotNull DefaultTreeModel treeModel, AbstractTreeStructure treeStructure, @Nullable Comparator<? super NodeDescriptor<?>> comparator, boolean updateIfInactive) { myBuilder = builder; myTree = tree; myTreeModel = treeModel; myActivityMonitor = UiActivityMonitor.getInstance(); myActivityId = new UiActivity.AsyncBgOperation("TreeUi " + this); addModelListenerToDiagnoseAccessOutsideEdt(); TREE_NODE_WRAPPER = AbstractTreeBuilder.createSearchingTreeNodeWrapper(); myTree.setModel(myTreeModel); setRootNode((DefaultMutableTreeNode)treeModel.getRoot()); myTreeStructure = treeStructure; myNodeDescriptorComparator = comparator; myUpdateIfInactive = updateIfInactive; UIUtil.invokeLaterIfNeeded(new TreeRunnable("AbstractTreeUi.init") { @Override public void perform() { if (!wasRootNodeInitialized()) { if (myRootNode.getChildCount() == 0) { insertLoadingNode(myRootNode, true); } } } }); myExpansionListener = new MyExpansionListener(); myTree.addTreeExpansionListener(myExpansionListener); mySelectionListener = new MySelectionListener(); myTree.addTreeSelectionListener(mySelectionListener); setUpdater(getBuilder().createUpdater()); myProgress = getBuilder().createProgressIndicator(); Disposer.register(getBuilder(), getUpdater()); if (myProgress != null) { Disposer.register(getBuilder(), () -> myProgress.cancel()); } UiNotifyConnector uiNotify = UiNotifyConnector.installOn(tree, new Activatable() { @Override public void showNotify() { myShowing = true; myWasEverShown = true; if (canInitiateNewActivity()) { activate(true); } } @Override public void hideNotify() { myShowing = false; if (canInitiateNewActivity()) { deactivate(); } } }); Disposer.register(getBuilder(), uiNotify); myTree.addFocusListener(myFocusListener); } | init |
279,046 | void () { if (!wasRootNodeInitialized()) { if (myRootNode.getChildCount() == 0) { insertLoadingNode(myRootNode, true); } } } | perform |
279,047 | void () { myShowing = true; myWasEverShown = true; if (canInitiateNewActivity()) { activate(true); } } | showNotify |
279,048 | void () { myShowing = false; if (canInitiateNewActivity()) { deactivate(); } } | hideNotify |
279,049 | boolean () { return !myNodeActions.isEmpty() || !myNodeChildrenActions.isEmpty(); } | isNodeActionsPending |
279,050 | void () { myNodeActions.clear(); myNodeChildrenActions.clear(); } | clearNodeActions |
279,051 | void (boolean forcedBusy, @Nullable Object element) { if (!myShowBusyIndicator.asBoolean()) return; boolean canUpdateBusyState = false; if (forcedBusy) { if (canYield() || isToBuildChildrenInBackground(element)) { canUpdateBusyState = true; } } else { canUpdateBusyState = true; } if (!canUpdateBusyState) return; if (myTree instanceof Tree tree) { boolean isBusy = !isReady(true) || forcedBusy; if (isBusy && tree.isShowing()) { tree.setPaintBusy(true); myBusyAlarm.cancelAllRequests(); myBusyAlarm.addRequest(myWaiterForReady, myWaitForReadyTime.asInteger()); } else { tree.setPaintBusy(false); } } } | maybeSetBusyAndScheduleWaiterForReady |
279,052 | void (boolean holdSize) { if (myTree instanceof Tree tree) { tree.setHoldSize(holdSize); } } | setHoldSize |
279,053 | void () { long now = System.currentTimeMillis(); long timeToCleanup = ourUi2Countdown; if (timeToCleanup != 0 && now >= timeToCleanup) { ourUi2Countdown = 0; Runnable runnable = new TreeRunnable("AbstractTreeUi.cleanUpAll") { @Override public void perform() { if (!canInitiateNewActivity()) return; myCleanupTask = null; getBuilder().cleanUp(); } }; if (isPassthroughMode()) { runnable.run(); } else { invokeLaterIfNeeded(false, runnable); } } } | cleanUpAll |
279,054 | void () { if (!canInitiateNewActivity()) return; myCleanupTask = null; getBuilder().cleanUp(); } | perform |
279,055 | void () { if (canInitiateNewActivity()) { cleanUpNow(); } } | perform |
279,056 | void () { if (!isReleased()) { runnable.run(); } } | perform |
279,057 | void (boolean byShowing) { cancelCurrentCleanupTask(); myCanProcessDeferredSelections = true; ourUi2Countdown = 0; if (!myWasEverShown || myUpdateFromRootRequested || myUpdateIfInactive) { getBuilder().updateFromRoot(); } getUpdater().showNotify(); myWasEverShown |= byShowing; } | activate |
279,058 | void () { if (myCleanupTask != null) { myCleanupTask.cancel(); myCleanupTask = null; } } | cancelCurrentCleanupTask |
279,059 | void () { cancelCurrentCleanupTask(); myCleanupTask = SimpleTimer.getInstance().setUp(new TreeRunnable("AbstractTreeUi.scheduleCleanUpAll") { @Override public void perform() { cleanUpAll(); } }, getClearOnHideDelay()); } | scheduleCleanUpAll |
279,060 | void () { cleanUpAll(); } | perform |
279,061 | void () { releaseNow(); } | perform |
279,062 | ProgressIndicator () { return myProgress; } | getProgress |
279,063 | void () { try (LockToken ignored = acquireLock()) { myTree.removeTreeExpansionListener(myExpansionListener); myTree.removeTreeSelectionListener(mySelectionListener); myTree.removeFocusListener(myFocusListener); disposeNode(getRootNode()); myElementToNodeMap.clear(); getUpdater().cancelAllRequests(); myWorker.clear(); clearWorkerTasks(); TREE_NODE_WRAPPER.setValue(null); if (myProgress != null) { myProgress.cancel(); } cancelCurrentCleanupTask(); myTree = null; setUpdater(null); myTreeStructure = null; myBuilder.releaseUi(); myBuilder = null; clearNodeActions(); myDeferredSelections.clear(); myDeferredExpansions.clear(); myYieldingDoneRunnables.clear(); } } | releaseNow |
279,064 | boolean () { return myBuilder == null; } | isReleased |
279,065 | void () { addSubtreeToUpdate(node); // at this point some tree updates may already have been run as a result of // in tests these updates may lead to the instance disposal, so getUpdater() at the next line may return null AbstractTreeUpdater updater = getUpdater(); if (updater != null) { updater.performUpdate(); } } | perform |
279,066 | AbstractTreeStructure () { return myTreeStructure; } | getTreeStructure |
279,067 | JTree () { return myTree; } | getTree |
279,068 | boolean (@NotNull DefaultMutableTreeNode node) { return TreeUtil.isAncestor(getRootNode(), node) && getRootNode() == myTreeModel.getRoot(); } | isNodeInStructure |
279,069 | boolean (@NotNull Object element, @NotNull DefaultMutableTreeNode node) { return isSameHierarchy(element, node) || isValidChildOfParent(element, node); } | isNodeValidForElement |
279,070 | boolean (@NotNull Object element, @NotNull DefaultMutableTreeNode node) { DefaultMutableTreeNode parent = (DefaultMutableTreeNode)node.getParent(); Object parentElement = getElementFor(parent); if (!isInStructure(parentElement)) return false; if (parent instanceof ElementNode) { return ((ElementNode)parent).isValidChild(element); } for (int i = 0; i < parent.getChildCount(); i++) { TreeNode child = parent.getChildAt(i); Object eachElement = getElementFor(child); if (element.equals(eachElement)) return true; } return false; } | isValidChildOfParent |
279,071 | boolean (@NotNull Object element, @NotNull DefaultMutableTreeNode node) { Object eachParent = element; DefaultMutableTreeNode eachParentNode = node; boolean valid; while (true) { if (eachParent == null) { valid = eachParentNode == null; break; } if (!eachParent.equals(getElementFor(eachParentNode))) { valid = false; break; } eachParent = getTreeStructure().getParentElement(eachParent); eachParentNode = (DefaultMutableTreeNode)eachParentNode.getParent(); } return valid; } | isSameHierarchy |
279,072 | void (@NotNull Object element) { getUpdater().performUpdate(); DefaultMutableTreeNode node = getNodeForElement(element, false); if (node == null) { List<Object> elements = new ArrayList<>(); while (true) { element = getTreeStructure().getParentElement(element); if (element == null) { break; } elements.add(0, element); } for (Object element1 : elements) { node = getNodeForElement(element1, false); if (node != null) { expand(node, true); } } } } | buildNodeForElement |
279,073 | void (Object @NotNull [] path) { getUpdater().performUpdate(); DefaultMutableTreeNode node = null; for (Object pathElement : path) { node = node == null ? getFirstNode(pathElement) : findNodeForChildElement(node, pathElement); if (node != null && node != path[path.length - 1]) { expand(node, true); } } } | buildNodeForPath |
279,074 | void (Comparator<? super NodeDescriptor<?>> nodeDescriptorComparator) { myNodeDescriptorComparator = nodeDescriptorComparator; myLastComparatorStamp = -1; getBuilder().queueUpdateFrom(getTreeStructure().getRootElement(), true); } | setNodeDescriptorComparator |
279,075 | AbstractTreeBuilder () { return myBuilder; } | getBuilder |
279,076 | void () { if (myUpdateIfInactive) { activate(false); } else { myUpdateFromRootRequested = true; } } | initRootNode |
279,077 | boolean (@NotNull TreeUpdatePass pass) { boolean wasCleanedUp = false; if (myRootNodeWasQueuedToInitialize) { Object root = getTreeStructure().getRootElement(); Object currentRoot = getElementFor(myRootNode); if (Comparing.equal(root, currentRoot)) return false; Object rootAgain = getTreeStructure().getRootElement(); if (root != rootAgain && !root.equals(rootAgain)) { assert false : "getRootElement() if called twice must return either root1 == root2 or root1.equals(root2)"; } cleanUpNow(); wasCleanedUp = true; } if (myRootNodeWasQueuedToInitialize) return true; myRootNodeWasQueuedToInitialize = true; Object rootElement = getTreeStructure().getRootElement(); addNodeAction(rootElement, false, node -> processDeferredActions()); Ref<NodeDescriptor<?>> rootDescriptor = new Ref<>(null); boolean bgLoading = isToBuildChildrenInBackground(rootElement); Runnable build = new TreeRunnable("AbstractTreeUi.initRootNodeNowIfNeeded: build") { @Override public void perform() { rootDescriptor.set(getTreeStructure().createDescriptor(rootElement, null)); getRootNode().setUserObject(rootDescriptor.get()); update(rootDescriptor.get(), true); pass.addToUpdated(rootDescriptor.get()); } }; Runnable update = new TreeRunnable("AbstractTreeUi.initRootNodeNowIfNeeded: update") { @Override public void perform() { Object fromDescriptor = getElementFromDescriptor(rootDescriptor.get()); if (!isNodeNull(fromDescriptor)) { createMapping(fromDescriptor, getRootNode()); } insertLoadingNode(getRootNode(), true); boolean willUpdate = false; if (!rootDescriptor.isNull() && isAutoExpand(rootDescriptor.get())) { willUpdate = myUnbuiltNodes.contains(getRootNode()); expand(getRootNode(), true); } ActionCallback callback; if (willUpdate) { callback = ActionCallback.DONE; } else { callback = updateNodeChildren(getRootNode(), pass, null, false, false, false, true, true); } callback.doWhenDone(new TreeRunnable("AbstractTreeUi.initRootNodeNowIfNeeded: on done updateNodeChildren") { @Override public void perform() { if (getRootNode().getChildCount() == 0) { myTreeModel.nodeChanged(getRootNode()); } } }); } }; if (bgLoading) { queueToBackground(build, update) .onSuccess(new TreeConsumer<>("AbstractTreeUi.initRootNodeNowIfNeeded: on processed queueToBackground") { @Override public void perform() { invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.initRootNodeNowIfNeeded: on processed queueToBackground later") { @Override public void perform() { myRootNodeInitialized = true; processNodeActionsIfReady(myRootNode); } }); } }); } else { build.run(); update.run(); myRootNodeInitialized = true; processNodeActionsIfReady(myRootNode); } return wasCleanedUp; } | initRootNodeNowIfNeeded |
279,078 | void () { rootDescriptor.set(getTreeStructure().createDescriptor(rootElement, null)); getRootNode().setUserObject(rootDescriptor.get()); update(rootDescriptor.get(), true); pass.addToUpdated(rootDescriptor.get()); } | perform |
279,079 | void () { Object fromDescriptor = getElementFromDescriptor(rootDescriptor.get()); if (!isNodeNull(fromDescriptor)) { createMapping(fromDescriptor, getRootNode()); } insertLoadingNode(getRootNode(), true); boolean willUpdate = false; if (!rootDescriptor.isNull() && isAutoExpand(rootDescriptor.get())) { willUpdate = myUnbuiltNodes.contains(getRootNode()); expand(getRootNode(), true); } ActionCallback callback; if (willUpdate) { callback = ActionCallback.DONE; } else { callback = updateNodeChildren(getRootNode(), pass, null, false, false, false, true, true); } callback.doWhenDone(new TreeRunnable("AbstractTreeUi.initRootNodeNowIfNeeded: on done updateNodeChildren") { @Override public void perform() { if (getRootNode().getChildCount() == 0) { myTreeModel.nodeChanged(getRootNode()); } } }); } | perform |
279,080 | void () { if (getRootNode().getChildCount() == 0) { myTreeModel.nodeChanged(getRootNode()); } } | perform |
279,081 | void () { invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.initRootNodeNowIfNeeded: on processed queueToBackground later") { @Override public void perform() { myRootNodeInitialized = true; processNodeActionsIfReady(myRootNode); } }); } | perform |
279,082 | void () { myRootNodeInitialized = true; processNodeActionsIfReady(myRootNode); } | perform |
279,083 | boolean (@NotNull NodeDescriptor<?> descriptor) { return isAutoExpand(descriptor, true); } | isAutoExpand |
279,084 | boolean (@NotNull NodeDescriptor<?> descriptor, boolean validate) { if (isAlwaysExpandedTree()) return false; boolean autoExpand = getBuilder().isAutoExpandNode(descriptor); Object element = getElementFromDescriptor(descriptor); if (validate && element != null) { autoExpand = validateAutoExpand(autoExpand, element); } if (!autoExpand && !myTree.isRootVisible()) { if (element != null && element.equals(getTreeStructure().getRootElement())) return true; } return autoExpand; } | isAutoExpand |
279,085 | boolean (boolean autoExpand, @NotNull Object element) { if (autoExpand) { int distance = getDistanceToAutoExpandRoot(element); if (distance < 0) { myAutoExpandRoots.add(element); } else { if (distance >= myAutoExpandDepth.asInteger() - 1) { autoExpand = false; } } if (autoExpand) { DefaultMutableTreeNode node = getNodeForElement(element, false); autoExpand = node != null && isInVisibleAutoExpandChain(node); } } return autoExpand; } | validateAutoExpand |
279,086 | boolean (@NotNull DefaultMutableTreeNode child) { TreeNode eachParent = child; while (eachParent != null) { if (myRootNode == eachParent) return true; NodeDescriptor<?> eachDescriptor = getDescriptorFrom(eachParent); if (eachDescriptor == null || !isAutoExpand(eachDescriptor, false)) { TreePath path = getPathFor(eachParent); return myWillBeExpanded.contains(path.getLastPathComponent()) || myTree.isExpanded(path) && myTree.isVisible(path); } eachParent = eachParent.getParent(); } return false; } | isInVisibleAutoExpandChain |
279,087 | int (@NotNull Object element) { int distance = 0; Object eachParent = element; while (eachParent != null) { if (myAutoExpandRoots.contains(eachParent)) break; eachParent = getTreeStructure().getParentElement(eachParent); distance++; } return eachParent != null ? distance : -1; } | getDistanceToAutoExpandRoot |
279,088 | boolean (@NotNull DefaultMutableTreeNode node) { NodeDescriptor<?> descriptor = getDescriptorFrom(node); return descriptor != null && isAutoExpand(descriptor); } | isAutoExpand |
279,089 | boolean () { return myTree instanceof AlwaysExpandedTree && ((AlwaysExpandedTree)myTree).isAlwaysExpanded(); } | isAlwaysExpandedTree |
279,090 | Promise<Boolean> (@NotNull NodeDescriptor<?> nodeDescriptor, boolean now) { Promise<Boolean> promise; if (now || isPassthroughMode()) { promise = Promises.resolvedPromise(update(nodeDescriptor)); } else { AsyncPromise<Boolean> result = new AsyncPromise<>(); promise = result; boolean bgLoading = isToBuildInBackground(nodeDescriptor); boolean edt = isEdt(); if (bgLoading) { if (edt) { AtomicBoolean changes = new AtomicBoolean(); queueToBackground(new TreeRunnable("AbstractTreeUi.update: build") { @Override public void perform() { changes.set(update(nodeDescriptor)); } }, new TreeRunnable("AbstractTreeUi.update: post") { @Override public void perform() { result.setResult(changes.get()); } } ); } else { result.setResult(update(nodeDescriptor)); } } else { if (edt || !myWasEverShown) { result.setResult(update(nodeDescriptor)); } else { invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.update: later") { @Override public void perform() { execute(new TreeRunnable("AbstractTreeUi.update: later execute") { @Override public void perform() { result.setResult(update(nodeDescriptor)); } }); } }); } } } promise.onSuccess(changes -> { if (!changes) { return; } invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.update: on done result") { @Override public void perform() { Object element = nodeDescriptor.getElement(); DefaultMutableTreeNode node = element == null ? null : getNodeForElement(element, false); if (node != null) { TreePath path = getPathFor(node); if (myTree.isVisible(path)) { updateNodeImageAndPosition(node); } } } }); }); return promise; } | update |
279,091 | void () { changes.set(update(nodeDescriptor)); } | perform |
279,092 | void () { result.setResult(changes.get()); } | perform |
279,093 | void () { execute(new TreeRunnable("AbstractTreeUi.update: later execute") { @Override public void perform() { result.setResult(update(nodeDescriptor)); } }); } | perform |
279,094 | void () { result.setResult(update(nodeDescriptor)); } | perform |
279,095 | void () { Object element = nodeDescriptor.getElement(); DefaultMutableTreeNode node = element == null ? null : getNodeForElement(element, false); if (node != null) { TreePath path = getPathFor(node); if (myTree.isVisible(path)) { updateNodeImageAndPosition(node); } } } | perform |
279,096 | boolean (@NotNull NodeDescriptor<?> nodeDescriptor) { while(true) { try (LockToken ignored = attemptLock()) { if (ignored == null) { // async children calculation is in progress under lock if (myProgress != null && myProgress.isRunning()) myProgress.cancel(); continue; } AtomicBoolean update = new AtomicBoolean(); execute(new TreeRunnable("AbstractTreeUi.update") { @Override public void perform() { nodeDescriptor.setUpdateCount(nodeDescriptor.getUpdateCount() + 1); update.set(getBuilder().updateNodeDescriptor(nodeDescriptor)); } }); return update.get(); } catch (IndexNotReadyException e) { warnOnIndexNotReady(e); return false; } catch (InterruptedException e) { LOG.info(e); return false; } } } | update |
279,097 | void () { nodeDescriptor.setUpdateCount(nodeDescriptor.getUpdateCount() + 1); update.set(getBuilder().updateNodeDescriptor(nodeDescriptor)); } | perform |
279,098 | void () { if (isPassthroughMode()) return; if ((isTreeShowing() || myWasEverShown) && !isEdt()) { LOG.error("Must be in event-dispatch thread"); } } | assertIsDispatchThread |
279,099 | boolean () { return SwingUtilities.isEventDispatchThread(); } | isEdt |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.