Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
279,300 | void (@NotNull Object element, @Nullable Runnable onDone) { runDone(new TreeRunnable("AbstractTreeUi.collapseChildren") { @Override public void perform() { DefaultMutableTreeNode node = getNodeForElement(element, false); if (node != null) { getTree().collapsePath(new TreePath(node.getPath())); runDone(onDone); } } }); } | collapseChildren |
279,301 | void () { DefaultMutableTreeNode node = getNodeForElement(element, false); if (node != null) { getTree().collapsePath(new TreePath(node.getPath())); runDone(onDone); } } | perform |
279,302 | void (@Nullable Runnable done) { if (done == null) return; if (!canInitiateNewActivity()) { if (done instanceof AbstractTreeBuilder.UserRunnable) { return; } } if (isYieldingNow()) { myYieldingDoneRunnables.add(done); } else { try { execute(done); } catch (ProcessCanceledException ignored) { } } } | runDone |
279,303 | void (Object element, @NotNull Runnable onDone, boolean parentsOnly, boolean checkIfInStructure, boolean canSmartExpand) { if (checkIfInStructure && !isInStructure(element)) { runDone(onDone); return; } if (wasRootNodeInitialized()) { List<Object> kidsToExpand = new ArrayList<>(); Object eachElement = element; DefaultMutableTreeNode firstVisible = null; while (true) { if (eachElement == null || !isValid(eachElement)) break; int preselected = getRowIfUnderSelection(eachElement); if (preselected >= 0) { firstVisible = (DefaultMutableTreeNode)getTree().getPathForRow(preselected).getLastPathComponent(); } else { firstVisible = getNodeForElement(eachElement, true); } if (eachElement != element || !parentsOnly) { kidsToExpand.add(eachElement); } if (firstVisible != null) break; eachElement = getTreeStructure().getParentElement(eachElement); if (eachElement == null) break; int i = kidsToExpand.indexOf(eachElement); if (i != -1) { try { Object existing = kidsToExpand.get(i); LOG.error("Tree path contains equal elements at different levels:\n" + " element: '" + eachElement + "'; " + eachElement.getClass() + " ("+System.identityHashCode(eachElement)+");\n" + "existing: '" + existing + "'; " + existing.getClass()+ " ("+System.identityHashCode(existing)+"); " + "path='" + kidsToExpand + "'; tree structure=" + myTreeStructure); } catch (AssertionError ignored) { } runDone(onDone); throw new ProcessCanceledException(); } } if (firstVisible == null) { runDone(onDone); } else if (kidsToExpand.isEmpty()) { DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode)firstVisible.getParent(); if (parentNode != null) { TreePath parentPath = new TreePath(parentNode.getPath()); if (!myTree.isExpanded(parentPath)) { expand(parentPath, canSmartExpand); } } runDone(onDone); } else { processExpand(firstVisible, kidsToExpand, kidsToExpand.size() - 1, onDone, canSmartExpand); } } else { deferExpansion(element, onDone, parentsOnly, canSmartExpand); } } | _expand |
279,304 | void (Object element, @NotNull Runnable onDone, boolean parentsOnly, boolean canSmartExpand) { myDeferredExpansions.add(new TreeRunnable("AbstractTreeUi.deferExpansion") { @Override public void perform() { _expand(element, onDone, parentsOnly, false, canSmartExpand); } }); } | deferExpansion |
279,305 | void () { _expand(element, onDone, parentsOnly, false, canSmartExpand); } | perform |
279,306 | void (DefaultMutableTreeNode toExpand, @NotNull List<Object> kidsToExpand, int expandIndex, @NotNull Runnable onDone, boolean canSmartExpand) { Object element = getElementFor(toExpand); if (element == null) { runDone(onDone); return; } addNodeAction(element, true, node -> { if (node.getChildCount() > 0 && !myTree.isExpanded(new TreePath(node.getPath()))) { if (!isAutoExpand(node)) { expand(node, canSmartExpand); } } if (expandIndex <= 0) { runDone(onDone); return; } checkPathAndMaybeRevalidate(kidsToExpand.get(expandIndex - 1), new TreeRunnable("AbstractTreeUi.processExpand") { @Override public void perform() { DefaultMutableTreeNode nextNode = getNodeForElement(kidsToExpand.get(expandIndex - 1), false); processExpand(nextNode, kidsToExpand, expandIndex - 1, onDone, canSmartExpand); } }, false, canSmartExpand); }); boolean childrenToUpdate = areChildrenToBeUpdated(toExpand); boolean expanded = myTree.isExpanded(getPathFor(toExpand)); boolean unbuilt = myUnbuiltNodes.contains(toExpand); if (expanded) { if (unbuilt || childrenToUpdate) { addSubtreeToUpdate(toExpand); } } else { expand(toExpand, canSmartExpand); } if (!unbuilt && !childrenToUpdate) { processNodeActionsIfReady(toExpand); } } | processExpand |
279,307 | void () { DefaultMutableTreeNode nextNode = getNodeForElement(kidsToExpand.get(expandIndex - 1), false); processExpand(nextNode, kidsToExpand, expandIndex - 1, onDone, canSmartExpand); } | perform |
279,308 | boolean (DefaultMutableTreeNode node) { return getUpdater().isEnqueuedToUpdate(node) || isUpdatingParent(node) || myCancelledBuild.containsKey(node); } | areChildrenToBeUpdated |
279,309 | boolean (@NotNull TreePath path) { return isNodeBeingBuilt(path.getLastPathComponent()); } | isNodeBeingBuilt |
279,310 | boolean (@NotNull Object node) { return getParentBuiltNode(node) != null || myRootNode == node && !wasRootNodeInitialized(); } | isNodeBeingBuilt |
279,311 | boolean (Object node) { return node instanceof DefaultMutableTreeNode && isLoadedInBackground(getElementFor(node)); } | isLoadingParentInBackground |
279,312 | void (@NotNull AbstractTreeStructure treeStructure) { myTreeStructure = treeStructure; clearUpdaterState(); } | setTreeStructure |
279,313 | AbstractTreeUpdater () { return myUpdater; } | getUpdater |
279,314 | void (@Nullable AbstractTreeUpdater updater) { myUpdater = updater; if (updater != null && myUpdateIfInactive) { updater.showNotify(); } if (myUpdater != null) { myUpdater.setPassThroughMode(myPassThroughMode); } } | setUpdater |
279,315 | DefaultMutableTreeNode () { return myRootNode; } | getRootNode |
279,316 | void (@NotNull DefaultMutableTreeNode rootNode) { myRootNode = rootNode; } | setRootNode |
279,317 | void () { if (!isInnerChange()) { clearUpdaterState(); myAutoExpandRoots.clear(); mySelectionIsAdjusted = false; } } | dropUpdaterStateIfExternalChange |
279,318 | void (@NotNull Object element, DefaultMutableTreeNode node) { element = TreeAnchorizer.getService().createAnchor(element); warnMap("myElementToNodeMap: createMapping: ", myElementToNodeMap); if (!myElementToNodeMap.containsKey(element)) { myElementToNodeMap.put(element, node); } else { Object value = myElementToNodeMap.get(element); List<DefaultMutableTreeNode> nodes; if (value instanceof DefaultMutableTreeNode) { nodes = new ArrayList<>(); nodes.add((DefaultMutableTreeNode)value); myElementToNodeMap.put(element, nodes); } else { //noinspection unchecked nodes = (List<DefaultMutableTreeNode>)value; } nodes.add(node); } } | createMapping |
279,319 | void (@NotNull Object element, DefaultMutableTreeNode node, @Nullable Object elementToPutNodeActionsFor) { element = TreeAnchorizer.getService().createAnchor(element); warnMap("myElementToNodeMap: removeMapping: ", myElementToNodeMap); Object value = myElementToNodeMap.get(element); if (value != null) { if (value instanceof DefaultMutableTreeNode) { if (value.equals(node)) { myElementToNodeMap.remove(element); } } else { //noinspection unchecked List<DefaultMutableTreeNode> nodes = (List<DefaultMutableTreeNode>)value; boolean reallyRemoved = nodes.remove(node); if (reallyRemoved) { if (nodes.isEmpty()) { myElementToNodeMap.remove(element); } } } } remapNodeActions(element, elementToPutNodeActionsFor); TreeAnchorizer.getService().freeAnchor(element); } | removeMapping |
279,320 | void (Object element, Object elementToPutNodeActionsFor) { _remapNodeActions(element, elementToPutNodeActionsFor, myNodeActions); _remapNodeActions(element, elementToPutNodeActionsFor, myNodeChildrenActions); warnMap("myNodeActions: remapNodeActions: ", myNodeActions); warnMap("myNodeChildrenActions: remapNodeActions: ", myNodeChildrenActions); } | remapNodeActions |
279,321 | void (Object element, @Nullable Object elementToPutNodeActionsFor, @NotNull Map<Object, List<NodeAction>> nodeActions) { List<NodeAction> actions = nodeActions.get(element); nodeActions.remove(element); if (elementToPutNodeActionsFor != null && actions != null) { nodeActions.put(elementToPutNodeActionsFor, actions); } } | _remapNodeActions |
279,322 | void (Object element, boolean shouldChildrenBeReady, @NotNull NodeAction action) { _addNodeAction(element, action, myNodeActions); if (shouldChildrenBeReady) { _addNodeAction(element, action, myNodeChildrenActions); } warnMap("myNodeActions: addNodeAction: ", myNodeActions); warnMap("myNodeChildrenActions: addNodeAction: ", myNodeChildrenActions); } | addNodeAction |
279,323 | void () { if (myActivityMonitor != null) { myActivityMonitor.addActivity(myActivityId, getUpdater().getModalityState()); } } | addActivity |
279,324 | void () { if (myActivityMonitor != null) { myActivityMonitor.removeActivity(myActivityId); } } | removeActivity |
279,325 | void (Object element, NodeAction action, @NotNull Map<Object, List<NodeAction>> map) { maybeSetBusyAndScheduleWaiterForReady(true, element); map.computeIfAbsent(element, k -> new ArrayList<>()).add(action); addActivity(); } | _addNodeAction |
279,326 | void () { if (!canInitiateNewActivity()) return; UpdaterTreeState state = new UpdaterTreeState(this); myTree.collapsePath(new TreePath(myTree.getModel().getRoot())); clearSelection(); getRootNode().removeAllChildren(); TREE_NODE_WRAPPER = AbstractTreeBuilder.createSearchingTreeNodeWrapper(); myRootNodeWasQueuedToInitialize = false; myRootNodeInitialized = false; clearNodeActions(); myElementToNodeMap.clear(); myDeferredSelections.clear(); myDeferredExpansions.clear(); myLoadedInBackground.clear(); myUnbuiltNodes.clear(); myUpdateFromRootRequested = true; myWorker.clear(); myTree.invalidate(); state.restore(null); } | cleanUpNow |
279,327 | void (long clearOnHideDelay) { myClearOnHideDelay = clearOnHideDelay; } | setClearOnHideDelay |
279,328 | void (@NotNull TreeSelectionEvent e) { if (mySilentSelect != null && mySilentSelect.equals(e.getNewLeadSelectionPath())) return; dropUpdaterStateIfExternalChange(); } | valueChanged |
279,329 | void (@NotNull TreeExpansionEvent event) { TreePath path = event.getPath(); if (mySilentExpand != null && mySilentExpand.equals(path)) return; dropUpdaterStateIfExternalChange(); if (myRequestedExpand != null && !myRequestedExpand.equals(path)) { _getReady().doWhenDone(new TreeRunnable("AbstractTreeUi.MyExpansionListener.treeExpanded") { @Override public void perform() { Object element = getElementFor(path.getLastPathComponent()); expand(element, null); } }); return; } DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent(); if (!myUnbuiltNodes.contains(node)) { removeLoading(node, false); Set<DefaultMutableTreeNode> childrenToUpdate = new HashSet<>(); for (int i = 0; i < node.getChildCount(); i++) { DefaultMutableTreeNode each = (DefaultMutableTreeNode)node.getChildAt(i); if (myUnbuiltNodes.contains(each)) { makeLoadingOrLeafIfNoChildren(each); childrenToUpdate.add(each); } } if (!childrenToUpdate.isEmpty()) { for (DefaultMutableTreeNode each : childrenToUpdate) { maybeUpdateSubtreeToUpdate(each); } } } else { getBuilder().expandNodeChildren(node); } processSmartExpand(node, canSmartExpand(node, true), false); processNodeActionsIfReady(node); } | treeExpanded |
279,330 | void () { Object element = getElementFor(path.getLastPathComponent()); expand(element, null); } | perform |
279,331 | void (@NotNull TreeExpansionEvent e) { dropUpdaterStateIfExternalChange(); TreePath path = e.getPath(); DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent(); NodeDescriptor<?> descriptor = getDescriptorFrom(node); if (descriptor == null) return; TreePath pathToSelect = null; if (isSelectionInside(node)) { pathToSelect = new TreePath(node.getPath()); } if (getBuilder().isDisposeOnCollapsing(descriptor)) { runDone(new TreeRunnable("AbstractTreeUi.MyExpansionListener.treeCollapsed") { @Override public void perform() { if (isDisposed(node)) return; TreePath nodePath = new TreePath(node.getPath()); if (myTree.isExpanded(nodePath)) return; removeChildren(node); makeLoadingOrLeafIfNoChildren(node); } }); if (node.equals(getRootNode())) { if (myTree.isRootVisible()) { //todo kirillk to investigate -- should be done by standard selction move //addSelectionPath(new TreePath(getRootNode().getPath()), true, Condition.FALSE); } } else { myTreeModel.reload(node); } } if (pathToSelect != null && myTree.isSelectionEmpty()) { addSelectionPath(pathToSelect, true, Conditions.alwaysFalse(), null); } } | treeCollapsed |
279,332 | void () { if (isDisposed(node)) return; TreePath nodePath = new TreePath(node.getPath()); if (myTree.isExpanded(nodePath)) return; removeChildren(node); makeLoadingOrLeafIfNoChildren(node); } | perform |
279,333 | void (@NotNull DefaultMutableTreeNode node) { @SuppressWarnings({"unchecked", "rawtypes"}) Enumeration<DefaultMutableTreeNode> children = (Enumeration)node.children(); for (DefaultMutableTreeNode child : Collections.list(children)) { disposeNode(child); } node.removeAllChildren(); nodeStructureChanged(node); } | removeChildren |
279,334 | void (@NotNull DefaultMutableTreeNode subtreeRoot) { if (!myUnbuiltNodes.contains(subtreeRoot)) return; TreePath path = getPathFor(subtreeRoot); if (myTree.getRowForPath(path) == -1) return; DefaultMutableTreeNode parent = getParentBuiltNode(subtreeRoot); if (parent == null) { if (!getBuilder().isAlwaysShowPlus(getDescriptorFrom(subtreeRoot))) { addSubtreeToUpdate(subtreeRoot); } } else if (parent != subtreeRoot) { addNodeAction(getElementFor(subtreeRoot), true, parent1 -> maybeUpdateSubtreeToUpdate(subtreeRoot)); } } | maybeUpdateSubtreeToUpdate |
279,335 | boolean (@NotNull DefaultMutableTreeNode parent) { TreePath path = new TreePath(myTreeModel.getPathToRoot(parent)); TreePath[] paths = myTree.getSelectionPaths(); if (paths == null) return false; for (TreePath path1 : paths) { if (path.isDescendant(path1)) return true; } return false; } | isSelectionInside |
279,336 | String () { return myElements + "->" + myChanges; } | toString |
279,337 | boolean (Object element) { NodeDescriptor<?> desc = getDescriptor(element); return myChanges.get(desc); } | isUpdated |
279,338 | long () { if (myNodeDescriptorComparator instanceof NodeDescriptor.NodeComparator) { long currentComparatorStamp = ((NodeDescriptor.NodeComparator<?>)myNodeDescriptorComparator).getStamp(); if (currentComparatorStamp > myLastComparatorStamp) { myOwnComparatorStamp = Math.max(myOwnComparatorStamp, currentComparatorStamp) + 1; } myLastComparatorStamp = currentComparatorStamp; return Math.max(currentComparatorStamp, myOwnComparatorStamp); } else { return myOwnComparatorStamp; } } | getComparatorStamp |
279,339 | boolean () { Application app = ApplicationManager.getApplication(); return app != null && app.isUnitTestMode(); } | isUnitTestingMode |
279,340 | void () { myTreeModel.addTreeModelListener(new TreeModelListener() { @Override public void treeNodesChanged(TreeModelEvent e) { assertIsDispatchThread(); } @Override public void treeNodesInserted(TreeModelEvent e) { assertIsDispatchThread(); } @Override public void treeNodesRemoved(TreeModelEvent e) { assertIsDispatchThread(); } @Override public void treeStructureChanged(TreeModelEvent e) { assertIsDispatchThread(); } }); } | addModelListenerToDiagnoseAccessOutsideEdt |
279,341 | void (TreeModelEvent e) { assertIsDispatchThread(); } | treeNodesChanged |
279,342 | void (TreeModelEvent e) { assertIsDispatchThread(); } | treeNodesInserted |
279,343 | void (TreeModelEvent e) { assertIsDispatchThread(); } | treeNodesRemoved |
279,344 | void (TreeModelEvent e) { assertIsDispatchThread(); } | treeStructureChanged |
279,345 | boolean (Object element) { if (element instanceof AbstractTreeNode<?> node) { element = node.getValue(); } return element == null; } | isNodeNull |
279,346 | boolean () { return myTree != null && myTreeModel != null && myTreeModel == myTree.getModel(); } | isConsistent |
279,347 | void (@NotNull AbstractTreeBuilder treeBuilder, @NotNull DefaultMutableTreeNode root, @NotNull List<Object> pathsToExpand, @NotNull List<Object> selectionPaths, boolean storeElementsOnly) { if (!treeBuilder.wasRootNodeInitialized()) return; JTree tree = treeBuilder.getTree(); if (tree != null) { storePaths(tree, root, pathsToExpand, selectionPaths, storeElementsOnly); } } | storePaths |
279,348 | void (@NotNull JTree tree, @NotNull DefaultMutableTreeNode root, @NotNull List<Object> pathsToExpand, @NotNull List<Object> selectionPaths, boolean storeElementsOnly) { TreePath path = new TreePath(root.getPath()); if (tree.isPathSelected(path)){ selectionPaths.add(storeElementsOnly ? ((NodeDescriptor<?>)root.getUserObject()).getElement() : path); } if (tree.isExpanded(path) || root.getChildCount() == 0){ pathsToExpand.add(storeElementsOnly ? ((NodeDescriptor<?>)root.getUserObject()).getElement() : path); _storePaths(tree, root, pathsToExpand, selectionPaths, storeElementsOnly); } } | storePaths |
279,349 | void (@NotNull JTree tree, @NotNull DefaultMutableTreeNode root, @NotNull List<Object> pathsToExpand, @NotNull List<Object> selectionPaths, boolean storeElementsOnly) { List<TreeNode> childNodes = TreeUtil.listChildren(root); for (final Object childNode1 : childNodes) { DefaultMutableTreeNode childNode = (DefaultMutableTreeNode)childNode1; TreePath path = new TreePath(childNode.getPath()); final Object userObject = childNode.getUserObject(); if (tree.isPathSelected(path)) { if (!(userObject instanceof NodeDescriptor)) { LOG.error("Node: " + childNode + "; userObject: " + userObject + " of class " + userObject.getClass()); return; } selectionPaths.add(storeElementsOnly ? ((NodeDescriptor<?>)userObject).getElement() : path); } if (tree.isExpanded(path) || childNode.getChildCount() == 0) { pathsToExpand.add(storeElementsOnly && userObject instanceof NodeDescriptor ? ((NodeDescriptor<?>)userObject).getElement() : path); _storePaths(tree, childNode, pathsToExpand, selectionPaths, storeElementsOnly); } } } | _storePaths |
279,350 | void (@NotNull AbstractTreeBuilder treeBuilder, @NotNull List<Object> pathsToExpand, @NotNull List<Object> selectionPaths, boolean elementsOnly) { JTree tree = treeBuilder.getTree(); if (!elementsOnly){ for (Object path : pathsToExpand) { tree.expandPath((TreePath)path); } tree.addSelectionPaths(selectionPaths.toArray(TreeUtil.EMPTY_TREE_PATH)); } else{ for (Object element : pathsToExpand) { treeBuilder.buildNodeForElement(element); DefaultMutableTreeNode node = treeBuilder.getNodeForElement(element); if (node != null) { tree.expandPath(new TreePath(node.getPath())); } } for (Object element : selectionPaths) { DefaultMutableTreeNode node = treeBuilder.getNodeForElement(element); if (node != null) { DefaultTreeModel treeModel = (DefaultTreeModel)tree.getModel(); tree.addSelectionPath(new TreePath(treeModel.getPathToRoot(node))); } } } } | restorePaths |
279,351 | boolean (@NotNull JTree tree, @NotNull DefaultMutableTreeNode node) { TreePath[] selectionPaths = tree.getSelectionPaths(); if (selectionPaths == null || selectionPaths.length == 0) return false; TreePath path = new TreePath(node.getPath()); for (TreePath selectionPath : selectionPaths) { if (path.isDescendant(selectionPath)) return true; } return false; } | isNodeOrChildSelected |
279,352 | void (@NotNull List<? super String> command, @NotNull String url) { command.add(url); } | addOpenUrlParameter |
279,353 | WebBrowserService () { return ApplicationManager.getApplication().getService(WebBrowserService.class); } | getInstance |
279,354 | boolean (@NotNull Language language) { return WebBrowserXmlService.getInstance().isHtmlOrXmlLanguage(language); } | isHtmlOrXmlLanguage |
279,355 | BrowserSpecificSettings () { return new ChromeSettings(); } | createBrowserSpecificSettings |
279,356 | BrowserSpecificSettings () { return new FirefoxSettings(); } | createBrowserSpecificSettings |
279,357 | String () { return myName; } | getName |
279,358 | Icon () { return myIcon; } | getIcon |
279,359 | String () { return myName; } | toString |
279,360 | Icon (@IconFlags int flags) { return getIcon(); } | getIcon |
279,361 | List<String> () { return Collections.emptyList(); } | getAdditionalParameters |
279,362 | BrowserSpecificSettings () { try { return (BrowserSpecificSettings)super.clone(); } catch (CloneNotSupportedException e) { throw new RuntimeException(e); } } | clone |
279,363 | void (@NotNull DocumentEvent e) { updateProfilesList(); } | textChanged |
279,364 | FileChooserDescriptor () { return new FileChooserDescriptor(true, false, false, false, false, false) { @Override public boolean isFileSelectable(@Nullable VirtualFile file) { return file != null && file.getName().equals(FirefoxUtil.PROFILES_INI_FILE) && super.isFileSelectable(file); } }.withShowHiddenFiles(SystemInfo.isUnix); } | createProfilesIniChooserDescriptor |
279,365 | boolean (@Nullable VirtualFile file) { return file != null && file.getName().equals(FirefoxUtil.PROFILES_INI_FILE) && super.isFileSelectable(file); } | isFileSelectable |
279,366 | JComponent () { return myMainPanel; } | createComponent |
279,367 | boolean () { return !Objects.equals(mySettings.getProfile(), getConfiguredProfileName()) || !Objects.equals(mySettings.getProfilesIniPath(), getConfiguredProfileIniPath()); } | isModified |
279,368 | void () { File defaultFile = FirefoxUtil.getDefaultProfileIniPath(); myDefaultProfilesIniPath = defaultFile != null ? defaultFile.getAbsolutePath() : ""; String path = mySettings.getProfilesIniPath(); myProfilesIniPathField.setText(path != null ? FileUtil.toSystemDependentName(path) : myDefaultProfilesIniPath); updateProfilesList(); String profile = mySettings.getProfile(); myProfileCombobox.setSelectedItem(profile == null ? defaultProfile : profile); } | reset |
279,369 | void () { final String profilesIniPath = myProfilesIniPathField.getText(); if (myLastProfilesIniPath != null && myLastProfilesIniPath.equals(profilesIniPath)) { return; } myProfileCombobox.removeAllItems(); final List<FirefoxProfile> profiles = FirefoxUtil.computeProfiles(new File(profilesIniPath)); final FirefoxProfile defaultProfile = FirefoxUtil.getDefaultProfile(profiles); this.defaultProfile = defaultProfile != null ? defaultProfile.getName() : null; for (FirefoxProfile profile : profiles) { //noinspection unchecked myProfileCombobox.addItem(profile.getName()); } if (!profiles.isEmpty()) { myProfileCombobox.setSelectedIndex(0); } myLastProfilesIniPath = profilesIniPath; } | updateProfilesList |
279,370 | List<FirefoxProfile> (@Nullable File profilesFile) { if (profilesFile == null || !profilesFile.isFile()) { return Collections.emptyList(); } try (BufferedReader reader = new BufferedReader(new FileReader(profilesFile))) { final List<FirefoxProfile> profiles = new SmartList<>(); boolean insideProfile = false; String currentName = null; String currentPath = null; boolean isDefault = false; boolean isRelative = false; boolean eof = false; while (!eof) { String line = reader.readLine(); if (line == null) { eof = true; line = "[]"; } else { line = line.trim(); } if (line.startsWith("[") && line.endsWith("]")) { if (!StringUtil.isEmpty(currentPath) && !StringUtil.isEmpty(currentName)) { profiles.add(new FirefoxProfile(currentName, currentPath, isDefault, isRelative)); } currentName = null; currentPath = null; isDefault = false; isRelative = false; insideProfile = StringUtil.startsWithIgnoreCase(line, "[Profile"); continue; } final int i = line.indexOf('='); if (i != -1 && insideProfile) { String name = line.substring(0, i).trim(); String value = line.substring(i + 1).trim(); if (name.equalsIgnoreCase("path")) { currentPath = value; } else if (name.equalsIgnoreCase("name")) { currentName = value; } else if (name.equalsIgnoreCase("default") && value.equals("1")) { isDefault = true; } else //noinspection SpellCheckingInspection if (name.equalsIgnoreCase("isrelative") && value.equals("1")) { isRelative = true; } } } return profiles; } catch (IOException e) { LOG.info(e); return Collections.emptyList(); } } | computeProfiles |
279,371 | File[] () { final String userHome = SystemProperties.getUserHome(); if (SystemInfo.isMac) { return new File[] { new File(userHome, "Library" + File.separator + "Mozilla" + File.separator + "Firefox"), new File(userHome, "Library" + File.separator + "Application Support" + File.separator + "Firefox"), }; } if (SystemInfo.isUnix) { return new File[] {new File(userHome, ".mozilla" + File.separator + "firefox")}; } String localPath = "Mozilla" + File.separator + "Firefox"; return new File[] { new File(System.getenv("APPDATA"), localPath), new File(userHome, "AppData" + File.separator + "Roaming" + File.separator + localPath), new File(userHome, "Application Data" + File.separator + localPath) }; } | getProfilesDirs |
279,372 | void (@Nullable String value) { myProfilesIniPath = PathUtil.toSystemIndependentName(StringUtil.nullize(value)); } | setProfilesIniPath |
279,373 | void (@Nullable String value) { myProfile = StringUtil.nullize(value); } | setProfile |
279,374 | Configurable () { return new FirefoxSettingsConfigurable(this); } | createConfigurable |
279,375 | List<String> () { List<FirefoxProfile> profiles = FirefoxUtil.computeProfiles(getProfilesIniFile()); if (profiles.size() >= 2) { FirefoxProfile profile = FirefoxUtil.findProfileByNameOrDefault(myProfile, profiles); if (profile != null && !profile.isDefault()) { return Arrays.asList("-P", profile.getName()); } } return Collections.emptyList(); } | getAdditionalParameters |
279,376 | boolean (Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } FirefoxSettings settings = (FirefoxSettings)o; return Objects.equals(myProfilesIniPath, settings.myProfilesIniPath) && Objects.equals(myProfile, settings.myProfile); } | equals |
279,377 | String () { return myPath; } | getPath |
279,378 | boolean () { return myRelative; } | isRelative |
279,379 | boolean () { return myDefault; } | isDefault |
279,380 | File (File profilesIniFile) { return myRelative ? new File(profilesIniFile.getParentFile(), myPath) : new File(myPath); } | getProfileDirectory |
279,381 | boolean () { return myUseCustomProfile; } | isUseCustomProfile |
279,382 | void (@Nullable String value) { myCommandLineOptions = StringUtil.nullize(value); } | setCommandLineOptions |
279,383 | void (@Nullable String value) { myUserDataDirectoryPath = PathUtil.toSystemIndependentName(StringUtil.nullize(value)); } | setUserDataDirectoryPath |
279,384 | void (boolean useCustomProfile) { myUseCustomProfile = useCustomProfile; } | setUseCustomProfile |
279,385 | List<String> () { if (myCommandLineOptions == null) { if (myUseCustomProfile && myUserDataDirectoryPath != null) { return Collections.singletonList(USER_DATA_DIR_ARG + FileUtilRt.toSystemDependentName(myUserDataDirectoryPath)); } else { return Collections.emptyList(); } } List<String> cliOptions = ParametersListUtil.parse(myCommandLineOptions); if (myUseCustomProfile && myUserDataDirectoryPath != null) { cliOptions.add(USER_DATA_DIR_ARG + FileUtilRt.toSystemDependentName(myUserDataDirectoryPath)); } return cliOptions; } | getAdditionalParameters |
279,386 | void (final @NotNull Map<String, String> environmentVariables) { myEnvironmentVariables = environmentVariables; } | setEnvironmentVariables |
279,387 | ChromeSettingsConfigurable () { return new ChromeSettingsConfigurable(this); } | createConfigurable |
279,388 | ChromeSettings () { ChromeSettings clone = (ChromeSettings)super.clone(); clone.myEnvironmentVariables = new HashMap<>(myEnvironmentVariables); return clone; } | clone |
279,389 | boolean (Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } ChromeSettings settings = (ChromeSettings)o; return myUseCustomProfile == settings.myUseCustomProfile && Objects.equals(myCommandLineOptions, settings.myCommandLineOptions) && (!myUseCustomProfile || Objects.equals(myUserDataDirectoryPath, settings.myUserDataDirectoryPath)) && myEnvironmentVariables.equals(settings.myEnvironmentVariables); } | equals |
279,390 | void (ActionEvent e) { myUserDataDirField.setEnabled(myUseCustomProfileCheckBox.isSelected()); } | actionPerformed |
279,391 | JComponent () { return myMainPanel; } | createComponent |
279,392 | boolean () { if (myUseCustomProfileCheckBox.isSelected() != mySettings.isUseCustomProfile() || !myCommandLineOptionsEditor.getText().equals(StringUtil.notNullize(mySettings.getCommandLineOptions()))) { return true; } String configuredPath = getConfiguredUserDataDirPath(); String storedPath = mySettings.getUserDataDirectoryPath(); if (myDefaultUserDirPath.equals(configuredPath) && storedPath == null) return false; return !configuredPath.equals(storedPath); } | isModified |
279,393 | String () { return FileUtil.toSystemIndependentName(myUserDataDirField.getText()); } | getConfiguredUserDataDirPath |
279,394 | void () { myCommandLineOptionsEditor.setText(mySettings.getCommandLineOptions()); myUseCustomProfileCheckBox.setSelected(mySettings.isUseCustomProfile()); myUserDataDirField.setEnabled(mySettings.isUseCustomProfile()); String path = mySettings.getUserDataDirectoryPath(); if (path != null) { myUserDataDirField.setText(FileUtil.toSystemDependentName(path)); } else { myUserDataDirField.setText(FileUtil.toSystemDependentName(myDefaultUserDirPath)); } } | reset |
279,395 | void () { if (!myUseCustomProfileCheckBox.isSelected()) { myUseCustomProfileCheckBox.doClick(0); } } | enableRecommendedOptions |
279,396 | String () { File dir = new File(PathManager.getConfigPath(), CHROME_USER_DATA); try { return FileUtil.toSystemIndependentName(dir.getCanonicalPath()); } catch (IOException e) { return FileUtil.toSystemIndependentName(dir.getAbsolutePath()); } } | getDefaultUserDataPath |
279,397 | String () { return "reference.settings.ide.settings.web.browsers.edit"; } | getHelpTopic |
279,398 | void (@NotNull PluginDescriptor pluginDescriptor) { myPluginDescriptor = pluginDescriptor; } | setPluginDescriptor |
279,399 | PluginDescriptor () { return myPluginDescriptor; } | getOldPluginDescriptor |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.