private void collectOptions(Set<String> optionNames, final List<Option> optionList) {
for (Option option : optionList) {
if (option.groupName != null) {
optionNames.add(option.groupName);
}
optionNames.add(option.title);
}
}
// {{{ saveSelection() method
public void saveSelection(Set<String> savedChecked, Set<String> savedSelection) {
if (entries.isEmpty()) return;
for (int i = 0, c = getRowCount(); i < c; i++) {
if ((Boolean) getValueAt(i, 0)) {
savedChecked.add(filteredEntries.get(i).toString());
}
}
int[] rows = table.getSelectedRows();
for (int i = 0; i < rows.length; i++) {
savedSelection.add(filteredEntries.get(rows[i]).toString());
}
} // }}}
public static Set<WorkingCopyFormat> getUpgradeFormats(
@NotNull WCInfo info, @NotNull List<WorkingCopyFormat> supportedFormats) {
Set<WorkingCopyFormat> canUpgradeTo = EnumSet.noneOf(WorkingCopyFormat.class);
for (WorkingCopyFormat format : supportedFormats) {
if (format.isOrGreater(info.getFormat())) {
canUpgradeTo.add(format);
}
}
canUpgradeTo.add(info.getFormat());
return canUpgradeTo;
}
/**
* Enumerates the resouces in a give package name. This works even if the resources are loaded
* from a jar file!
*
* <p>Adapted from code by mikewse on the java.sun.com message boards.
* http://forum.java.sun.com/thread.jsp?forum=22&thread=30984
*
* @param packageName The package to enumerate
* @return A Set of Strings for each resouce in the package.
*/
public static Set getResoucesInPackage(String packageName) throws IOException {
String localPackageName;
if (packageName.endsWith("/")) {
localPackageName = packageName;
} else {
localPackageName = packageName + '/';
}
Enumeration dirEnum = ClassLoader.getSystemResources(localPackageName);
Set names = new HashSet();
// Loop CLASSPATH directories
while (dirEnum.hasMoreElements()) {
URL resUrl = (URL) dirEnum.nextElement();
// Pointing to filesystem directory
if (resUrl.getProtocol().equals("file")) {
File dir = new File(resUrl.getFile());
File[] files = dir.listFiles();
if (files != null) {
for (int i = 0; i < files.length; i++) {
File file = files[i];
if (file.isDirectory()) continue;
names.add(localPackageName + file.getName());
}
}
// Pointing to Jar file
} else if (resUrl.getProtocol().equals("jar")) {
JarURLConnection jconn = (JarURLConnection) resUrl.openConnection();
JarFile jfile = jconn.getJarFile();
Enumeration entryEnum = jfile.entries();
while (entryEnum.hasMoreElements()) {
JarEntry entry = (JarEntry) entryEnum.nextElement();
String entryName = entry.getName();
// Exclude our own directory
if (entryName.equals(localPackageName)) continue;
String parentDirName = entryName.substring(0, entryName.lastIndexOf('/') + 1);
if (!parentDirName.equals(localPackageName)) continue;
names.add(entryName);
}
} else {
// Invalid classpath entry
}
}
return names;
}
public TooltipRenderer calcTooltipRenderer(
@NotNull final Collection<RangeHighlighter> highlighters) {
LineTooltipRenderer bigRenderer = null;
// do not show same tooltip twice
Set<String> tooltips = null;
for (RangeHighlighter highlighter : highlighters) {
final Object tooltipObject = highlighter.getErrorStripeTooltip();
if (tooltipObject == null) continue;
final String text = tooltipObject.toString();
if (tooltips == null) {
tooltips = new THashSet<String>();
}
if (tooltips.add(text)) {
if (bigRenderer == null) {
bigRenderer = new LineTooltipRenderer(text, new Object[] {highlighters});
} else {
bigRenderer.addBelow(text);
}
}
}
return bigRenderer;
}
private int countDistinctGlobalSectors(Set<Sector> neighbors) {
Set<GlobalSector> globalSectors = new HashSet<GlobalSector>();
for (Sector s : neighbors) {
globalSectors.add(s.getParent());
}
return globalSectors.size();
}
private void reloadSdk() {
final Sdk currentSdk = getSelectedSdk();
if (currentSdk != null) {
myModifiedModificators.add(myModificators.get(currentSdk));
reloadSdk(currentSdk);
}
}
private void updateRightTreeModel() {
Set<PsiFile> deps = new HashSet<PsiFile>();
Set<PsiFile> scope = getSelectedScope(myLeftTree);
myIllegalsInRightTree = new HashSet<PsiFile>();
for (PsiFile psiFile : scope) {
Map<DependencyRule, Set<PsiFile>> illegalDeps = myIllegalDependencies.get(psiFile);
if (illegalDeps != null) {
for (final DependencyRule rule : illegalDeps.keySet()) {
myIllegalsInRightTree.addAll(illegalDeps.get(rule));
}
}
final Set<PsiFile> psiFiles = myDependencies.get(psiFile);
if (psiFiles != null) {
for (PsiFile file : psiFiles) {
if (file != null && file.isValid()) {
deps.add(file);
}
}
}
}
deps.removeAll(scope);
myRightTreeExpansionMonitor.freeze();
myRightTree.setModel(buildTreeModel(deps, myRightTreeMarker));
myRightTreeExpansionMonitor.restore();
expandFirstLevel(myRightTree);
}
private void addCreatedSdk(@Nullable final Sdk sdk, boolean newVirtualEnv) {
if (sdk != null) {
final PySdkService sdkService = PySdkService.getInstance();
sdkService.restoreSdk(sdk);
boolean isVirtualEnv = PythonSdkType.isVirtualEnv(sdk);
if (isVirtualEnv && !newVirtualEnv) {
AddVEnvOptionsDialog dialog = new AddVEnvOptionsDialog(myMainPanel);
dialog.show();
if (dialog.getExitCode() != DialogWrapper.OK_EXIT_CODE) {
return;
}
SdkModificator modificator = myModificators.get(sdk);
setSdkAssociated(modificator, !dialog.makeAvailableToAll());
myModifiedModificators.add(modificator);
}
final Sdk oldSdk = myProjectSdksModel.findSdk(sdk);
if (oldSdk == null) {
myProjectSdksModel.addSdk(sdk);
}
refreshSdkList();
mySdkList.setSelectedValue(myProjectSdksModel.findSdk(sdk.getName()), true);
mySdkListChanged = true;
}
}
private static void updateExistingPluginInfo(
IdeaPluginDescriptor descr, IdeaPluginDescriptor existing) {
int state = StringUtil.compareVersionNumbers(descr.getVersion(), existing.getVersion());
final PluginId pluginId = existing.getPluginId();
final String idString = pluginId.getIdString();
final JDOMExternalizableStringList installedPlugins =
PluginManagerUISettings.getInstance().getInstalledPlugins();
if (!installedPlugins.contains(idString)
&& !((IdeaPluginDescriptorImpl) existing).isDeleted()) {
installedPlugins.add(idString);
}
final PluginManagerUISettings updateSettings = PluginManagerUISettings.getInstance();
if (state > 0
&& !PluginManager.isIncompatible(descr)
&& !updatedPlugins.contains(descr.getPluginId())) {
NewVersions2Plugins.put(pluginId, 1);
if (!updateSettings.myOutdatedPlugins.contains(idString)) {
updateSettings.myOutdatedPlugins.add(idString);
}
final IdeaPluginDescriptorImpl plugin = (IdeaPluginDescriptorImpl) existing;
plugin.setDownloadsCount(descr.getDownloads());
plugin.setVendor(descr.getVendor());
plugin.setVendorEmail(descr.getVendorEmail());
plugin.setVendorUrl(descr.getVendorUrl());
plugin.setUrl(descr.getUrl());
} else {
updateSettings.myOutdatedPlugins.remove(idString);
if (NewVersions2Plugins.remove(pluginId) != null) {
updatedPlugins.add(pluginId);
}
}
}
private void fireTilesChangedIncludeBorder(Set<Tile> tiles) {
if (showBorder
&& (tileProvider instanceof Dimension)
&& (((Dimension) tileProvider).getDim() == DIM_NORMAL)
&& (((Dimension) tileProvider).getBorder() != null)) {
final Set<Point> coordSet = new HashSet<>();
for (Tile tile : tiles) {
final int tileX = tile.getX(),
tileY = tile.getY(),
borderSize = ((Dimension) tileProvider).getBorderSize();
for (int dx = -borderSize; dx <= borderSize; dx++) {
for (int dy = -borderSize; dy <= borderSize; dy++) {
coordSet.add(getTileCoordinates(tileX + dx, tileY + dy));
}
}
}
for (TileListener listener : listeners) {
listener.tilesChanged(this, coordSet);
}
} else {
Set<Point> coords = tiles.stream().map(this::getTileCoordinates).collect(Collectors.toSet());
for (TileListener listener : listeners) {
listener.tilesChanged(this, coords);
}
}
}
@NotNull
public Change[] getSelectedChanges() {
Set<Change> changes = new LinkedHashSet<Change>();
final TreePath[] paths = getSelectionPaths();
if (paths == null) {
return new Change[0];
}
for (TreePath path : paths) {
ChangesBrowserNode<?> node = (ChangesBrowserNode) path.getLastPathComponent();
changes.addAll(node.getAllChangesUnder());
}
if (changes.isEmpty()) {
final List<VirtualFile> selectedModifiedWithoutEditing = getSelectedModifiedWithoutEditing();
if (selectedModifiedWithoutEditing != null && !selectedModifiedWithoutEditing.isEmpty()) {
for (VirtualFile file : selectedModifiedWithoutEditing) {
AbstractVcs vcs = ProjectLevelVcsManager.getInstance(myProject).getVcsFor(file);
if (vcs == null) continue;
final VcsCurrentRevisionProxy before =
VcsCurrentRevisionProxy.create(file, myProject, vcs.getKeyInstanceMethod());
if (before != null) {
ContentRevision afterRevision = new CurrentContentRevision(new FilePathImpl(file));
changes.add(new Change(before, afterRevision, FileStatus.HIJACKED));
}
}
}
}
return changes.toArray(new Change[changes.size()]);
}
public static void updateExistingPlugin(
IdeaPluginDescriptor descriptor, IdeaPluginDescriptor existing) {
if (existing != null) {
updateExistingPluginInfo(descriptor, existing);
updatedPlugins.add(existing.getPluginId());
}
}
private void checkForEmptyAndDuplicatedNames(
MyNode rootNode,
String prefix,
String title,
Class<? extends NamedConfigurable> configurableClass,
boolean recursively)
throws ConfigurationException {
final Set<String> names = new HashSet<String>();
for (int i = 0; i < rootNode.getChildCount(); i++) {
final MyNode node = (MyNode) rootNode.getChildAt(i);
final NamedConfigurable scopeConfigurable = node.getConfigurable();
if (configurableClass.isInstance(scopeConfigurable)) {
final String name = scopeConfigurable.getDisplayName();
if (name.trim().length() == 0) {
selectNodeInTree(node);
throw new ConfigurationException("Name should contain non-space characters");
}
if (names.contains(name)) {
final NamedConfigurable selectedConfigurable = getSelectedConfigurable();
if (selectedConfigurable == null
|| !Comparing.strEqual(selectedConfigurable.getDisplayName(), name)) {
selectNodeInTree(node);
}
throw new ConfigurationException(
CommonBundle.message("smth.already.exist.error.message", prefix, name), title);
}
names.add(name);
}
if (recursively) {
checkForEmptyAndDuplicatedNames(node, prefix, title, configurableClass, true);
}
}
}
@Override
public void saveAllDocuments() {
ApplicationManager.getApplication().assertIsDispatchThread();
myMultiCaster.beforeAllDocumentsSaving();
if (myUnsavedDocuments.isEmpty()) return;
final Map<Document, IOException> failedToSave = new HashMap<Document, IOException>();
final Set<Document> vetoed = new HashSet<Document>();
while (true) {
int count = 0;
for (Document document : myUnsavedDocuments) {
if (failedToSave.containsKey(document)) continue;
if (vetoed.contains(document)) continue;
try {
doSaveDocument(document);
} catch (IOException e) {
//noinspection ThrowableResultOfMethodCallIgnored
failedToSave.put(document, e);
} catch (SaveVetoException e) {
vetoed.add(document);
}
count++;
}
if (count == 0) break;
}
if (!failedToSave.isEmpty()) {
handleErrorsOnSave(failedToSave);
}
}
private void editSdk(final Sdk currentSdk) {
final SdkModificator modificator = myModificators.get(currentSdk);
final EditSdkDialog dialog =
new EditSdkDialog(
myProject,
modificator,
s -> {
if (isDuplicateSdkName(s, currentSdk)) {
return PyBundle.message("sdk.details.dialog.error.duplicate.name");
}
return null;
});
if (dialog.showAndGet()) {
mySdkList.repaint();
final boolean pathChanged = !Comparing.equal(currentSdk.getHomePath(), dialog.getHomePath());
if (!modificator.getName().equals(dialog.getName())
|| pathChanged
|| dialog.isAssociateChanged()) {
myModifiedModificators.add(modificator);
modificator.setName(dialog.getName());
modificator.setHomePath(dialog.getHomePath());
if (dialog.isAssociateChanged()) {
setSdkAssociated(modificator, dialog.associateWithProject());
}
if (pathChanged) {
reloadSdk(currentSdk);
}
}
}
}
public void writeMap(Cluster cluster, float yBar) {
Set<Submission> subSet = new HashSet<Submission>(cluster.size());
String documents = "";
for (int i = 0; i < cluster.size(); i++) {
Submission sub = submissions.elementAt(cluster.getSubmissionAt(i));
documents += sub.name + " ";
subSet.add(sub);
}
documents = documents.trim();
String theme =
ThemeGenerator.generateThemes(subSet, this.program.get_themewords(), false, this.program);
mapString +=
"<area shape=\"rect\" coords=\""
+ (cluster.x - 2)
+ ","
+ (yBar)
+ ","
+ (cluster.x + 2)
+ ","
+ (cluster.y + 2)
+ "\" onMouseover=\"set('"
+ cluster.size()
+ "','"
+ trimStringToLength(String.valueOf(cluster.getSimilarity()), 6)
+ "','"
+ trimStringToLength(documents, 50)
+ "','"
+ theme
+ "')\" ";
// if (cluster.size() == 1)
// mapString += "href=\"submission"+cluster.getSubmissionAt(0)+".html\">\n";
// else
mapString += "nohref>\n";
}
private Set<Key> getActiveProviderKeys() {
Set<Key> result = new HashSet<Key>();
for (BeforeRunTask task : myModel.getItems()) {
result.add(task.getProviderId());
}
return result;
}
@Override
public void onSuccess(@Nullable final DataNode<ProjectData> externalProject) {
if (externalProject == null) {
return;
}
Collection<DataNode<ModuleData>> moduleNodes =
ExternalSystemApiUtil.findAll(externalProject, ProjectKeys.MODULE);
for (DataNode<ModuleData> node : moduleNodes) {
myExternalModulePaths.add(node.getData().getLinkedExternalProjectPath());
}
ExternalSystemApiUtil.executeProjectChangeAction(
true,
new DisposeAwareProjectChange(myProject) {
@Override
public void execute() {
ProjectRootManagerEx.getInstanceEx(myProject)
.mergeRootsChangesDuring(
new Runnable() {
@Override
public void run() {
myProjectDataManager.importData(
externalProject.getKey(),
Collections.singleton(externalProject),
myProject,
true);
}
});
processOrphanProjectLibraries();
}
});
if (--myCounter[0] <= 0) {
processOrphanModules();
}
}
private void calculateRoots() {
final ModuleManager moduleManager = ModuleManager.getInstance(myProject);
// assertion for read access inside
final Module[] modules =
ApplicationManager.getApplication()
.runReadAction(
new Computable<Module[]>() {
public Module[] compute() {
return moduleManager.getModules();
}
});
final TreeSet<VirtualFile> checkSet =
new TreeSet<VirtualFile>(FilePathComparator.getInstance());
myRoots = new HashSet<VirtualFile>();
myRoots.addAll(myInitialRoots);
checkSet.addAll(myInitialRoots);
for (Module module : modules) {
final VirtualFile[] files = ModuleRootManager.getInstance(module).getContentRoots();
for (VirtualFile file : files) {
final VirtualFile floor = checkSet.floor(file);
if (floor != null) {
myModulesSet.put(file, module.getName());
myRoots.add(file);
}
}
}
}
public void addSelection(Point p) {
ExprPoint ep = null;
int minDist = -1;
for (ExprPoint ex : points) {
int sd = ex.screenDist(p);
if (ep == null || sd < minDist) {
ep = ex;
minDist = sd;
}
}
if (ep != null) {
Set<Point> remove = new HashSet<Point>();
for (Point rp : selections.keySet()) {
if (selections.get(rp).equals(ep)) {
remove.add(rp);
}
}
selections.put(p, ep);
for (Point rp : remove) {
selections.remove(rp);
}
}
}
private void _addTestOrSuite(@NotNull final SMTestProxy newTestOrSuite) {
final SMTestProxy parentSuite = newTestOrSuite.getParent();
assert parentSuite != null;
// Tree
final Update update =
new Update(parentSuite) {
@Override
public void run() {
myRequests.remove(this);
myTreeBuilder.updateTestsSubtree(parentSuite);
}
};
if (ApplicationManager.getApplication().isUnitTestMode()) {
update.run();
} else if (myRequests.add(update) && !myUpdateQueue.isDisposed()) {
myUpdateQueue.addRequest(update, 100);
}
myTreeBuilder.repaintWithParents(newTestOrSuite);
myAnimator.setCurrentTestCase(newTestOrSuite);
if (TestConsoleProperties.TRACK_RUNNING_TEST.value(myProperties)) {
if (myLastSelected == null || myLastSelected == newTestOrSuite) {
myLastSelected = null;
selectAndNotify(newTestOrSuite);
}
}
}
@NotNull
private static Collection<PsiLanguageInjectionHost> collectInjectionHosts(
@NotNull PsiFile file, @NotNull TextRange range) {
Stack<PsiElement> toProcess = new Stack<PsiElement>();
for (PsiElement e = file.findElementAt(range.getStartOffset());
e != null;
e = e.getNextSibling()) {
if (e.getTextRange().getStartOffset() >= range.getEndOffset()) {
break;
}
toProcess.push(e);
}
if (toProcess.isEmpty()) {
return Collections.emptySet();
}
Set<PsiLanguageInjectionHost> result = null;
while (!toProcess.isEmpty()) {
PsiElement e = toProcess.pop();
if (e instanceof PsiLanguageInjectionHost) {
if (result == null) {
result = ContainerUtilRt.newHashSet();
}
result.add((PsiLanguageInjectionHost) e);
} else {
for (PsiElement child = e.getFirstChild(); child != null; child = child.getNextSibling()) {
if (e.getTextRange().getStartOffset() >= range.getEndOffset()) {
break;
}
toProcess.push(child);
}
}
}
return result == null ? Collections.<PsiLanguageInjectionHost>emptySet() : result;
}
public void handleCreateNotify(XEvent xev) {
XAnyEvent xany = xev.get_xany();
if (xany.get_window() != getWindow()) {
synchronized (getStateLock()) {
children.add(xany.get_window());
}
}
}
private Set<String> getDownstream(String mut) {
Set<String> tfs = new HashSet<String>();
tfs.add(mut);
if (depth > 1) tfs.addAll(travSt.getDownstream(tfs, depth - 1));
return travExp.getDownstream(tfs);
}
@Override
public void draw(Drawing context) {
all = new LinkedHashSet<>();
this.breadthFirst(this.both())
.forEach(
x -> {
Rect r = x.properties.get(frame);
{
Map<String, Function<Box, FLine>> drawing =
x.properties.computeIfAbsent(interactiveDrawing, k -> new LinkedHashMap<>());
if (drawing != null && drawing.size() > 0) {
Iterator<Function<Box, FLine>> it = drawing.values().iterator();
while (it.hasNext()) {
Function<Box, FLine> f = it.next();
FLine fl = f.apply(x);
if (fl == null) it.remove();
else all.add(fl);
}
}
}
{
Map<String, Supplier<FLine>> drawing =
x.properties.computeIfAbsent(
interactiveLines, k -> new LinkedHashMapAndArrayList<>());
if (drawing != null && drawing.size() > 0) {
Iterator<Supplier<FLine>> it = drawing.values().iterator();
while (it.hasNext()) {
Supplier<FLine> f = it.next();
FLine fl = f.get();
if (fl == null) it.remove();
else all.add(fl);
}
}
}
});
for (FLine f : all)
f.attributes.computeIfAbsent(
projectedArea,
(k) ->
new Cached<FLine, Object, Area>(
(fline, previously) -> projectFLineToArea(fline),
(fline) -> new Object[] {fline, fline.getModCount()}));
}
{
for (myjava.gui.syntax.Painter painter : myjava.gui.syntax.Painter.getPainters()) {
painterComboBox.addItem(painter);
EntryListPanel panel = new EntryListPanel(painter);
listPanelSet.add(panel);
centerPanel.add(panel, painter.getName());
}
componentSet.addAll(Arrays.asList(matchBracket, painterComboBox, centerPanel));
}
private Set<Object> doFilter(Set<Object> elements) {
Set<Object> result = new LinkedHashSet<Object>();
for (Object o : elements) {
if (myElementClass.isInstance(o) && getFilter().isAccepted((T) o)) {
result.add(o);
}
}
return result;
}
/**
* Takes the raw page lines represented as one continuous line and sorts the text by the y access
* of the word bounds. The words are then sliced into separate lines base on y changes. And
* finally each newly sorted line is sorted once more by each words x coordinate.
*/
public void sortAndFormatText() {
ArrayList<LineText> visiblePageLines = new ArrayList<LineText>(pageLines);
// create new array for storing the sorted lines
ArrayList<LineText> sortedPageLines = sortLinesVertically(visiblePageLines);
// try and insert the option words on existing lines
if (sortedPageLines.size() == 0) {
sortedPageLines = getVisiblePageLines(true);
} else {
insertOptionalLines(sortedPageLines);
}
// sort again
sortedPageLines = sortLinesVertically(sortedPageLines);
// do a rough check for duplicate strings that are sometimes generated
// by Chrystal Reports. Enable with
// -Dorg.icepdf.core.views.page.text.trim.duplicates=true
if (checkForDuplicates) {
for (final LineText lineText : sortedPageLines) {
final List<WordText> words = lineText.getWords();
if (words.size() > 0) {
final List<WordText> trimmedWords = new ArrayList<WordText>();
final Set<String> refs = new HashSet<String>();
for (final WordText wordText : words) {
// use regular rectangle so get a little rounding.
final String key = wordText.getText() + wordText.getBounds().getBounds();
if (refs.add(key)) {
trimmedWords.add(wordText);
}
}
lineText.setWords(trimmedWords);
}
}
}
// sort each line by x coordinate.
if (sortedPageLines.size() > 0) {
for (LineText lineText : sortedPageLines) {
Collections.sort(lineText.getWords(), new WordPositionComparator());
}
}
// recalculate the line bounds.
if (sortedPageLines.size() > 0) {
for (LineText lineText : sortedPageLines) {
lineText.getBounds();
}
}
// sort the lines
if (sortedPageLines.size() > 0 && !preserveColumns) {
Collections.sort(sortedPageLines, new LinePositionComparator());
}
// assign back the sorted lines.
this.sortedPageLines = sortedPageLines;
}
private static Set<PsiElement> getAllParents(PsiElement element) {
Set<PsiElement> parents = new java.util.HashSet<PsiElement>();
while (element != null) {
parents.add(element);
if (element instanceof PsiFile) break;
element = element.getParent();
}
return parents;
}