@Override
public void writeExternal(Element element) throws WriteExternalException {
List<HighlightSeverity> list = getOrderAsList(getOrderMap());
for (HighlightSeverity severity : list) {
Element info = new Element(INFO_TAG);
String severityName = severity.getName();
final SeverityBasedTextAttributes infoType = getAttributesBySeverity(severity);
if (infoType != null) {
infoType.writeExternal(info);
final Color color = myRendererColors.get(severityName);
if (color != null) {
info.setAttribute(COLOR_ATTRIBUTE, Integer.toString(color.getRGB() & 0xFFFFFF, 16));
}
element.addContent(info);
}
}
if (myReadOrder != null && !myReadOrder.isEmpty()) {
myReadOrder.writeExternal(element);
} else if (!getDefaultOrder().equals(list)) {
final JDOMExternalizableStringList ext =
new JDOMExternalizableStringList(Collections.nCopies(getOrderMap().size(), ""));
getOrderMap()
.forEachEntry(
new TObjectIntProcedure<HighlightSeverity>() {
@Override
public boolean execute(HighlightSeverity orderSeverity, int oIdx) {
ext.set(oIdx, orderSeverity.getName());
return true;
}
});
ext.writeExternal(element);
}
}
@SuppressWarnings("deprecation")
public ExpectedHighlightingData(@NotNull Document document, @Nullable PsiFile file) {
myDocument = document;
myFile = file;
myText = document.getText();
registerHighlightingType(
ERROR_MARKER, new ExpectedHighlightingSet(HighlightSeverity.ERROR, false, true));
registerHighlightingType(
WARNING_MARKER, new ExpectedHighlightingSet(HighlightSeverity.WARNING, false, false));
registerHighlightingType(
WEAK_WARNING_MARKER,
new ExpectedHighlightingSet(HighlightSeverity.WEAK_WARNING, false, false));
registerHighlightingType(
INJECT_MARKER,
new ExpectedHighlightingSet(HighlightInfoType.INJECTED_FRAGMENT_SEVERITY, false, false));
registerHighlightingType(
INFO_MARKER, new ExpectedHighlightingSet(HighlightSeverity.INFORMATION, false, false));
registerHighlightingType(
SYMBOL_NAME_MARKER,
new ExpectedHighlightingSet(HighlightInfoType.SYMBOL_TYPE_SEVERITY, false, false));
for (SeveritiesProvider provider : Extensions.getExtensions(SeveritiesProvider.EP_NAME)) {
for (HighlightInfoType type : provider.getSeveritiesHighlightInfoTypes()) {
HighlightSeverity severity = type.getSeverity(null);
registerHighlightingType(
severity.getName(), new ExpectedHighlightingSet(severity, false, true));
}
}
registerHighlightingType(
END_LINE_HIGHLIGHT_MARKER,
new ExpectedHighlightingSet(HighlightSeverity.ERROR, true, true));
registerHighlightingType(
END_LINE_WARNING_MARKER,
new ExpectedHighlightingSet(HighlightSeverity.WARNING, true, false));
}
public Icon getRendererIconByIndex(int i) {
final HighlightSeverity severity = getSeverityByIndex(i);
HighlightDisplayLevel level = HighlightDisplayLevel.find(severity);
if (level != null) {
return level.getIcon();
}
return HighlightDisplayLevel.createIconByMask(myRendererColors.get(severity.getName()));
}
public void registerSeverity(@NotNull SeverityBasedTextAttributes info, Color renderColor) {
final HighlightSeverity severity = info.getType().getSeverity(null);
myMap.put(severity.getName(), info);
if (renderColor != null) {
myRendererColors.put(severity.getName(), renderColor);
}
myOrderMap = null;
HighlightDisplayLevel.registerSeverity(
severity, getHighlightInfoTypeBySeverity(severity).getAttributesKey());
severitiesChanged();
}
@Override
public void readExternal(Element element) throws InvalidDataException {
myMap.clear();
myRendererColors.clear();
final List children = element.getChildren(INFO_TAG);
for (Object child : children) {
final Element infoElement = (Element) child;
final SeverityBasedTextAttributes highlightInfo =
new SeverityBasedTextAttributes(infoElement);
Color color = null;
final String colorStr = infoElement.getAttributeValue(COLOR_ATTRIBUTE);
if (colorStr != null) {
color = new Color(Integer.parseInt(colorStr, 16));
}
registerSeverity(highlightInfo, color);
}
myReadOrder = new JDOMExternalizableStringList();
myReadOrder.readExternal(element);
List<HighlightSeverity> read = new ArrayList<HighlightSeverity>(myReadOrder.size());
final List<HighlightSeverity> knownSeverities = getDefaultOrder();
for (String name : myReadOrder) {
HighlightSeverity severity = getSeverity(name);
if (severity == null || !knownSeverities.contains(severity)) continue;
read.add(severity);
}
OrderMap orderMap = fromList(read);
if (orderMap.isEmpty()) {
orderMap = fromList(knownSeverities);
} else {
// enforce include all known
List<HighlightSeverity> list = getOrderAsList(orderMap);
for (int i = 0; i < knownSeverities.size(); i++) {
HighlightSeverity stdSeverity = knownSeverities.get(i);
if (!list.contains(stdSeverity)) {
for (int oIdx = 0; oIdx < list.size(); oIdx++) {
HighlightSeverity orderSeverity = list.get(oIdx);
HighlightInfoType type = STANDARD_SEVERITIES.get(orderSeverity.getName());
if (type != null && knownSeverities.indexOf(type.getSeverity(null)) > i) {
list.add(oIdx, stdSeverity);
myReadOrder = null;
break;
}
}
}
}
orderMap = fromList(list);
}
myOrderMap = orderMap;
severitiesChanged();
}
@Override
public boolean equals(final Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
final HighlightInfoTypeImpl that = (HighlightInfoTypeImpl) o;
if (!Comparing.equal(myAttributesKey, that.myAttributesKey)) return false;
if (!mySeverity.equals(that.mySeverity)) return false;
return true;
}
@NotNull
public HighlightInfoType.HighlightInfoTypeImpl getHighlightInfoTypeBySeverity(
@NotNull HighlightSeverity severity) {
HighlightInfoType infoType = STANDARD_SEVERITIES.get(severity.getName());
if (infoType != null) {
return (HighlightInfoType.HighlightInfoTypeImpl) infoType;
}
if (severity == HighlightSeverity.INFORMATION) {
return (HighlightInfoType.HighlightInfoTypeImpl) HighlightInfoType.INFORMATION;
}
final SeverityBasedTextAttributes type = getAttributesBySeverity(severity);
return (HighlightInfoType.HighlightInfoTypeImpl)
(type == null ? HighlightInfoType.WARNING : type.getType());
}
public static void registerStandard(
@NotNull HighlightInfoType highlightInfoType, @NotNull HighlightSeverity highlightSeverity) {
STANDARD_SEVERITIES.put(highlightSeverity.getName(), highlightInfoType);
}
private SeverityBasedTextAttributes getAttributesBySeverity(@NotNull HighlightSeverity severity) {
return myMap.get(severity.getName());
}
public SeverityBasedTextAttributes unregisterSeverity(@NotNull HighlightSeverity severity) {
return myMap.remove(severity.getName());
}
// return true if panel needs to be rebuilt
boolean updatePanel(@NotNull DaemonCodeAnalyzerStatus status, Project project) {
progressBarsEnabled = false;
progressBarsCompleted = null;
statistics = "";
passStatusesVisible = false;
statusLabel = null;
statusExtraLine = null;
boolean result = false;
if (!status.passStati.equals(new ArrayList<>(passes.keySet()))) {
// passes set has changed
rebuildPassesMap(status);
result = true;
}
if (PowerSaveMode.isEnabled()) {
statusLabel = "Code analysis is disabled in power save mode";
status.errorAnalyzingFinished = true;
icon = AllIcons.General.SafeMode;
return result;
}
if (status.reasonWhyDisabled != null) {
statusLabel = "No analysis has been performed";
statusExtraLine = "(" + status.reasonWhyDisabled + ")";
passStatusesVisible = true;
progressBarsCompleted = Boolean.FALSE;
icon = AllIcons.General.InspectionsTrafficOff;
return result;
}
if (status.reasonWhySuspended != null) {
statusLabel = "Code analysis has been suspended";
statusExtraLine = "(" + status.reasonWhySuspended + ")";
passStatusesVisible = true;
progressBarsCompleted = Boolean.FALSE;
icon = AllIcons.General.InspectionsPause;
return result;
}
Icon icon = AllIcons.General.InspectionsOK;
for (int i = status.errorCount.length - 1; i >= 0; i--) {
if (status.errorCount[i] != 0) {
icon = SeverityRegistrar.getSeverityRegistrar(project).getRendererIconByIndex(i);
break;
}
}
if (status.errorAnalyzingFinished) {
boolean isDumb = project != null && DumbService.isDumb(project);
if (isDumb) {
statusLabel = "Shallow analysis completed";
statusExtraLine = "Complete results will be available after indexing";
} else {
statusLabel = DaemonBundle.message("analysis.completed");
}
progressBarsCompleted = Boolean.TRUE;
} else {
statusLabel = DaemonBundle.message("performing.code.analysis");
passStatusesVisible = true;
progressBarsEnabled = true;
progressBarsCompleted = null;
}
int currentSeverityErrors = 0;
@org.intellij.lang.annotations.Language("HTML")
String text = "";
for (int i = status.errorCount.length - 1; i >= 0; i--) {
if (status.errorCount[i] > 0) {
final HighlightSeverity severity =
SeverityRegistrar.getSeverityRegistrar(project).getSeverityByIndex(i);
String name =
status.errorCount[i] > 1
? StringUtil.pluralize(severity.getName().toLowerCase())
: severity.getName().toLowerCase();
text +=
status.errorAnalyzingFinished
? DaemonBundle.message("errors.found", status.errorCount[i], name)
: DaemonBundle.message("errors.found.so.far", status.errorCount[i], name);
text += "<br>";
currentSeverityErrors += status.errorCount[i];
}
}
if (currentSeverityErrors == 0) {
text +=
status.errorAnalyzingFinished
? DaemonBundle.message("no.errors.or.warnings.found")
: DaemonBundle.message("no.errors.or.warnings.found.so.far") + "<br>";
}
statistics = XmlStringUtil.wrapInHtml(text);
this.icon = icon;
return result;
}
@Override
public int hashCode() {
int result = mySeverity.hashCode();
result = 29 * result + myAttributesKey.hashCode();
return result;
}
public void writeExternal(Element element) throws WriteExternalException {
mySeverity.writeExternal(element);
myAttributesKey.writeExternal(element);
}
