@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();
}