@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()]); }
private List<String> mergeAttributes(Map<String, List<File>> inputFiles) { Set<String> mergedAttributes = new HashSet<String>(); for (List<File> plateFiles : inputFiles.values()) { mergedAttributes.addAll(getAssayParamNames(plateFiles)); } for (String barcode : inputFiles.keySet()) { List<File> plateFiles = inputFiles.get(barcode); HashSet<String> curSetAttribtues = new HashSet<String>(getAssayParamNames(plateFiles)); if (!mergedAttributes.equals(curSetAttribtues)) { logger.error( "The attributes '" + curSetAttribtues + "'of plate '" + barcode + "' are not the same as the collected ones: '" + mergedAttributes + "'"); } } return new ArrayList<String>(mergedAttributes); }
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); } } } }
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); }
public boolean checkCanRemove(final List<? extends PackagingElementNode<?>> nodes) { Set<PackagingNodeSource> rootSources = new HashSet<PackagingNodeSource>(); for (PackagingElementNode<?> node : nodes) { rootSources.addAll(getRootNodeSources(node.getNodeSources())); } if (!rootSources.isEmpty()) { final String message; if (rootSources.size() == 1) { final String name = rootSources.iterator().next().getPresentableName(); message = "The selected node belongs to '" + name + "' element. Do you want to remove the whole '" + name + "' element from the artifact?"; } else { message = "The selected node belongs to " + nodes.size() + " elements. Do you want to remove all these elements from the artifact?"; } final int answer = Messages.showYesNoDialog( myArtifactsEditor.getMainComponent(), message, "Remove Elements", null); if (answer != Messages.YES) return false; } return true; }
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); }
{ 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)); }
@NotNull public static List<GotoRelatedItem> collectRelatedItems( @NotNull PsiElement contextElement, @Nullable DataContext dataContext) { Set<GotoRelatedItem> items = ContainerUtil.newLinkedHashSet(); for (GotoRelatedProvider provider : Extensions.getExtensions(GotoRelatedProvider.EP_NAME)) { items.addAll(provider.getItems(contextElement)); if (dataContext != null) { items.addAll(provider.getItems(dataContext)); } } GotoRelatedItem[] result = items.toArray(new GotoRelatedItem[items.size()]); Arrays.sort( result, (i1, i2) -> { String o1 = i1.getGroup(); String o2 = i2.getGroup(); return StringUtil.isEmpty(o1) ? 1 : StringUtil.isEmpty(o2) ? -1 : o1.compareTo(o2); }); return Arrays.asList(result); }
/** * This method generates the time series for the methods and puts it in an HTML string. The * methods are sorted according to the greatest average time for each method. * * @param dataBase the database to aggregate the statistics for * @return the html representing the series of timings for the method */ @SuppressWarnings({"unchecked", "rawtypes"}) protected String methodSeries(final IDataBase dataBase) { Comparator<Method> comparator = new Comparator<Method>() { public int compare(Method o1, Method o2) { Double o1Average = calculator.averageMethodTime(o1); Double o2Average = calculator.averageMethodTime(o2); // We want a descending table, i.e. the most expensive at the top return o2Average.compareTo(o1Average); } }; Set<Method> sortedMethods = new TreeSet<>(comparator); List<Method> methods = dataBase.find(Method.class); sortedMethods.addAll(methods); List<Snapshot<?, ?>> snapshots = methods.size() > 0 ? methods.get(0).getSnapshots() : new ArrayList<Snapshot<?, ?>>(); Element tableElement = tableElement(snapshots); for (Method method : sortedMethods) { Class<?, ?> klass = (Class<?, ?>) method.getParent(); String className = klass.getName(); String methodName = method.getName(); Element rowElement = addElement(tableElement, "tr", null); addElement(rowElement, "td", className); addElement(rowElement, "td", methodName); addElement(rowElement, "td", Double.toString(calculator.averageMethodTime(method))); addElement(rowElement, "td", Double.toString(calculator.averageMethodNetTime(method))); addElement(rowElement, "td", Double.toString(calculator.totalMethodTime(method))); addElement(rowElement, "td", Double.toString(calculator.totalNetMethodTime(method))); addElement(rowElement, "td", Integer.toString(method.getInvocations())); Element dataElement = addElement(rowElement, "td", null); Element imageElement = addElement(dataElement, "img", null); // Add the method series graph for the average and total time for the method List<Double> methodSeries = calculator.methodSeries(method); String url = buildGraph(IConstants.METHOD_SERIES, method, methodSeries); addAttributes(imageElement, new String[] {"src"}, new String[] {url}); dataElement = addElement(rowElement, "td", null); imageElement = addElement(dataElement, "img", null); // Add the method change graph, i.e. the change in the average time for the method List<Double> methodChangeSeries = calculator.methodChangeSeries(method); url = buildGraph(IConstants.METHOD_CHANGE_SERIES, method, methodChangeSeries); addAttributes(imageElement, new String[] {"src"}, new String[] {url}); } Document document = tableElement.getDocument(); return prettyPrint(document); }
private List<FilePath> getSelectedFilePaths(final Object tag) { Set<FilePath> files = new HashSet<FilePath>(); final TreePath[] paths = getSelectionPaths(); if (paths != null) { for (TreePath path : paths) { if (path.getPathCount() > 1) { ChangesBrowserNode firstNode = (ChangesBrowserNode) path.getPathComponent(1); if (tag == null || firstNode.getUserObject() == tag) { ChangesBrowserNode<?> node = (ChangesBrowserNode) path.getLastPathComponent(); files.addAll(node.getAllFilePathsUnder()); } } } } return new ArrayList<FilePath>(files); }
private void updateInSelectionHighlighters() { if (mySearchResults.getEditor() == null) return; final SelectionModel selectionModel = mySearchResults.getEditor().getSelectionModel(); int[] starts = selectionModel.getBlockSelectionStarts(); int[] ends = selectionModel.getBlockSelectionEnds(); final HashSet<RangeHighlighter> toRemove = new HashSet<RangeHighlighter>(); Set<RangeHighlighter> toAdd = new HashSet<RangeHighlighter>(); for (RangeHighlighter highlighter : myHighlighters) { boolean intersectsWithSelection = false; for (int i = 0; i < starts.length; ++i) { TextRange selectionRange = new TextRange(starts[i], ends[i]); intersectsWithSelection = selectionRange.intersects(highlighter.getStartOffset(), highlighter.getEndOffset()) && selectionRange.getEndOffset() != highlighter.getStartOffset() && highlighter.getEndOffset() != selectionRange.getStartOffset(); if (intersectsWithSelection) break; } final Object userData = highlighter.getUserData(IN_SELECTION_KEY); if (userData != null) { if (!intersectsWithSelection) { if (userData == IN_SELECTION2) { HighlightManager.getInstance(mySearchResults.getProject()) .removeSegmentHighlighter(mySearchResults.getEditor(), highlighter); toRemove.add(highlighter); } else { highlighter.putUserData(IN_SELECTION_KEY, null); } } } else if (intersectsWithSelection) { TextRange cursor = mySearchResults.getCursor(); if (cursor != null && highlighter.getStartOffset() == cursor.getStartOffset() && highlighter.getEndOffset() == cursor.getEndOffset()) continue; final RangeHighlighter toAnnotate = highlightRange( new TextRange(highlighter.getStartOffset(), highlighter.getEndOffset()), new TextAttributes(null, null, Color.WHITE, EffectType.ROUNDED_BOX, 0), toAdd); highlighter.putUserData(IN_SELECTION_KEY, IN_SELECTION1); toAnnotate.putUserData(IN_SELECTION_KEY, IN_SELECTION2); } } myHighlighters.removeAll(toRemove); myHighlighters.addAll(toAdd); }
protected static String getStatusToolTip() { StringBuffer result = new StringBuffer("<html>"); // NOI18N result.append("<table cellspacing=\"0\" border=\"0\">"); // NOI18N final CollabManager manager = CollabManager.getDefault(); if (manager != null) { Set sessions = new TreeSet( new Comparator() { public int compare(Object o1, Object o2) { String s1 = ((CollabSession) o1).getUserPrincipal().getDisplayName(); String s2 = ((CollabSession) o2).getUserPrincipal().getDisplayName(); return s1.compareTo(s2); } }); sessions.addAll(Arrays.asList(manager.getSessions())); if (sessions.size() == 0) { result.append("<tr><td>"); // NOI18N result.append(getStatusDescription(CollabPrincipal.STATUS_OFFLINE)); result.append("</td></tr>"); // NOI18N } else { for (Iterator i = sessions.iterator(); i.hasNext(); ) { CollabPrincipal principal = ((CollabSession) i.next()).getUserPrincipal(); result.append("<tr>"); // NOI18N result.append("<td>"); // NOI18N result.append("<b>"); // NOI18N result.append(principal.getDisplayName()); result.append(": "); // NOI18N result.append("</b>"); // NOI18N result.append("</td>"); // NOI18N result.append("<td>"); // NOI18N result.append(getStatusDescription(principal.getStatus())); result.append("</td>"); // NOI18N result.append("</tr>"); // NOI18N } } } result.append("</table>"); // NOI18N return result.toString(); }
private List<LocallyDeletedChange> getSelectedLocallyDeletedChanges() { Set<LocallyDeletedChange> files = new HashSet<LocallyDeletedChange>(); final TreePath[] paths = getSelectionPaths(); if (paths != null) { for (TreePath path : paths) { if (path.getPathCount() > 1) { ChangesBrowserNode firstNode = (ChangesBrowserNode) path.getPathComponent(1); if (firstNode.getUserObject() == TreeModelBuilder.LOCALLY_DELETED_NODE) { ChangesBrowserNode<?> node = (ChangesBrowserNode) path.getLastPathComponent(); final List<LocallyDeletedChange> objectsUnder = node.getAllObjectsUnder(LocallyDeletedChange.class); files.addAll(objectsUnder); } } } } return new ArrayList<LocallyDeletedChange>(files); }
public List<VcsException> commit( @NotNull List<Change> changes, @NotNull String message, @NotNull NullableFunction<Object, Object> parametersHolder, Set<String> feedback) { List<VcsException> exceptions = new ArrayList<VcsException>(); Map<VirtualFile, Collection<Change>> sortedChanges = sortChangesByGitRoot(changes, exceptions); log.assertTrue( !sortedChanges.isEmpty(), "Trying to commit an empty list of changes: " + changes); for (Map.Entry<VirtualFile, Collection<Change>> entry : sortedChanges.entrySet()) { final VirtualFile root = entry.getKey(); try { File messageFile = createMessageFile(root, message); try { final Set<FilePath> added = new HashSet<FilePath>(); final Set<FilePath> removed = new HashSet<FilePath>(); for (Change change : entry.getValue()) { switch (change.getType()) { case NEW: case MODIFICATION: added.add(change.getAfterRevision().getFile()); break; case DELETED: removed.add(change.getBeforeRevision().getFile()); break; case MOVED: FilePath afterPath = change.getAfterRevision().getFile(); FilePath beforePath = change.getBeforeRevision().getFile(); added.add(afterPath); if (!GitFileUtils.shouldIgnoreCaseChange( afterPath.getPath(), beforePath.getPath())) { removed.add(beforePath); } break; default: throw new IllegalStateException("Unknown change type: " + change.getType()); } } try { try { Set<FilePath> files = new HashSet<FilePath>(); files.addAll(added); files.addAll(removed); commit( myProject, root, files, messageFile, myNextCommitAuthor, myNextCommitAmend, myNextCommitAuthorDate); } catch (VcsException ex) { PartialOperation partialOperation = isMergeCommit(ex); if (partialOperation == PartialOperation.NONE) { throw ex; } if (!mergeCommit( myProject, root, added, removed, messageFile, myNextCommitAuthor, exceptions, partialOperation)) { throw ex; } } } finally { if (!messageFile.delete()) { log.warn("Failed to remove temporary file: " + messageFile); } } } catch (VcsException e) { exceptions.add(e); } } catch (IOException ex) { //noinspection ThrowableInstanceNeverThrown exceptions.add(new VcsException("Creation of commit message file failed", ex)); } } if (myNextCommitIsPushed != null && myNextCommitIsPushed.booleanValue() && exceptions.isEmpty()) { // push UIUtil.invokeLaterIfNeeded( new Runnable() { public void run() { GitPusher.showPushDialogAndPerformPush( myProject, ServiceManager.getService(myProject, GitPlatformFacade.class)); } }); } return exceptions; }
public SyntaxTab() { super(new BorderLayout(), "Syntax highlighting"); /* * upper checkboxes */ JPanel upper = new JPanel(new GridLayout(2, 1, 0, 0)); upper.setOpaque(false); upper.add(MyPanel.wrap(highlightSyntax)); upper.add(MyPanel.wrap(matchBracket)); highlightSyntax.addActionListener( new ActionListener() { @Override public void actionPerformed(ActionEvent ev) { SyntaxTab.this.updateComponentStatus(); } }); this.add(upper, BorderLayout.PAGE_START); /* * upper panel (painters) */ painterComboBox.setSelectedItem(myjava.gui.syntax.Painter.getCurrentInstance()); painterComboBox.setFont(f13); if (isMetal) painterComboBox.setBackground(Color.WHITE); painterComboBox.addItemListener(this.painterChangeListener); JButton addPainter = new MyButton("+") { { if (isMetal) { this.setPreferredSize(new Dimension(28, 28)); } } @Override public void actionPerformed(ActionEvent ev) { String name; do { name = JOptionPane.showInputDialog( SyntaxTab.this, "Enter a name:", "Name", JOptionPane.QUESTION_MESSAGE); } while (!myjava.gui.syntax.Painter.isValidPrompt(name, SyntaxTab.this)); if ((name != null) && (!name.isEmpty())) { // name is valid, neither cancelled nor pressed enter directly myjava.gui.syntax.Painter newPainter = ((myjava.gui.syntax.Painter) (painterComboBox.getSelectedItem())) .newInstance(name); addPainter(newPainter); System.out.println("now set, should call listener"); painterComboBox.setSelectedItem(newPainter); // auto-call ItemListener(s) } } }; JButton removePainter = new MyButton("-") { { if (isMetal) { this.setPreferredSize(new Dimension(28, 28)); } } @Override public void actionPerformed(ActionEvent ev) { myjava.gui.syntax.Painter painter = (myjava.gui.syntax.Painter) (painterComboBox.getSelectedItem()); if (painter.equals(myjava.gui.syntax.Painter.getDefaultInstance())) { JOptionPane.showMessageDialog( SyntaxTab.this, "The default painter cannot be removed.", "Error", JOptionPane.ERROR_MESSAGE); } else { int option = JOptionPane.showConfirmDialog( SyntaxTab.this, "Remove painter \"" + painter.getName() + "\"?", "Confirm", JOptionPane.YES_NO_OPTION); if (option == JOptionPane.YES_OPTION) { // remove "painter" removedPainters.add(painter); painterComboBox.removeItemListener(painterChangeListener); painterComboBox.setSelectedItem(myjava.gui.syntax.Painter.getDefaultInstance()); painterComboBox.removeItem(painter); for (Iterator<EntryListPanel> it = listPanelSet.iterator(); it.hasNext(); ) { EntryListPanel panel = it.next(); if (panel.getPainter().getName().equals(painter.getName())) { System.out.println("removing, then break"); it.remove(); centerPanel.remove(panel); break; } } painterComboBox.addItemListener(painterChangeListener); cardLayout.show( centerPanel, myjava.gui.syntax.Painter.getDefaultInstance().getName()); } } } }; // lower part JPanel center = new JPanel(new BorderLayout()); JLabel selectLabel = new MyLabel("Selected painter:"); center.add( MyPanel.wrap(MyPanel.CENTER, selectLabel, painterComboBox, addPainter, removePainter), BorderLayout.PAGE_START); componentSet.addAll(Arrays.asList(selectLabel, addPainter, removePainter)); center.add(centerPanel, BorderLayout.CENTER); this.add(center, BorderLayout.CENTER); cardLayout.show(centerPanel, myjava.gui.syntax.Painter.getCurrentInstance().getName()); }
/** * Linear forward search algorithm * * @param p * @param algorithm * @param targetVars * @param _computeAll * @return */ private boolean linearForwardSearch( PlanningContext context, EvaluationAlgorithm algorithm, boolean _computeAll) { /* * while iterating through hashset, items cant be removed from/added to * that set. Theyre collected into these sets and added/removedall * together after iteration is finished */ Set<Var> newVars = new LinkedHashSet<Var>(); Set<Var> relOutputs = new LinkedHashSet<Var>(); Set<Var> removableVars = new LinkedHashSet<Var>(); boolean changed = true; if (isLinearLoggingOn()) logger.debug( "------Starting linear planning with (sub)goals: " + context.getRemainingGoals() + "--------"); if (isLinearLoggingOn()) logger.debug("Algorithm " + algorithm); int counter = 1; while ((!_computeAll && changed && !context.getRemainingGoals().isEmpty()) || (changed && _computeAll)) { if (isLinearLoggingOn()) logger.debug("----Iteration " + counter + " ----"); counter++; changed = false; // iterate through all knownvars if (isLinearLoggingOn()) logger.debug("Known:" + context.getKnownVars()); for (Var var : context.getKnownVars()) { if (isLinearLoggingOn()) logger.debug("Current Known: " + var); // Check the relations of all components for (Rel rel : var.getRels()) { if (isLinearLoggingOn()) logger.debug("And its rel: " + rel); if (context.isAvailableRel(rel)) { context.removeUnknownInput(rel, var); if (isLinearLoggingOn()) logger.debug("problem contains it " + rel); removableVars.add(var); if (context.isRelReadyToUse(rel) && rel.getType() != RelType.TYPE_METHOD_WITH_SUBTASK) { if (isLinearLoggingOn()) logger.debug("rel is ready to be used " + rel); boolean relIsNeeded = false; if (isLinearLoggingOn()) logger.debug("its outputs " + rel.getOutputs()); for (Var relVar : rel.getOutputs()) { if (!context.getFoundVars().contains(relVar)) { relIsNeeded = true; } } if (rel.getOutputs().isEmpty()) { relIsNeeded = true; } if (isLinearLoggingOn()) logger.debug("relIsNeeded " + relIsNeeded); if (relIsNeeded) { if (isLinearLoggingOn()) logger.debug("needed rel: " + rel); if (!rel.getOutputs().isEmpty()) { relOutputs.clear(); unfoldVarsToSet(rel.getOutputs(), relOutputs); newVars.addAll(relOutputs); context.getFoundVars().addAll(relOutputs); } algorithm.addRel(rel); if (isLinearLoggingOn()) logger.debug("algorithm " + algorithm); } context.removeRel(rel); changed = true; } } } } // remove targets if they have already been found for (Iterator<Var> targetIter = context.getRemainingGoals().iterator(); targetIter.hasNext(); ) { Var targetVar = targetIter.next(); if (context.getFoundVars().contains(targetVar)) { targetIter.remove(); } } if (isLinearLoggingOn()) logger.debug("foundvars " + context.getFoundVars()); context.getKnownVars().addAll(newVars); context.getKnownVars().removeAll(removableVars); newVars.clear(); } if (isLinearLoggingOn()) logger.debug("algorithm " + algorithm); if (!_computeAll) { Optimizer.optimize(context, algorithm); if (isLinearLoggingOn()) logger.debug("optimized algorithm " + algorithm); } if (isLinearLoggingOn()) logger.debug("\n---!!!Finished linear planning!!!---\n"); return context.getRemainingGoals().isEmpty() || context.getFoundVars().containsAll(context.getAllGoals()); }
public void addAllIconRenderers(Collection<EditorMessageIconRenderer> renderers) { assert SwingUtilities.isEventDispatchThread() : "LeftEditorHighlighter.addAllIconRenderers() should be called in eventDispatchThread"; myIconRenderers.addAll(renderers); relayoutOnIconRendererChanges(); }