private static String getAnnotationType(VisageLineBreakpoint b, boolean isConditional) {
boolean isInvalid = b.getValidity() == VALIDITY.INVALID;
String annotationType;
if (b instanceof VisageLineBreakpoint) {
annotationType =
b.isEnabled()
? (isConditional
? EditorContext.CONDITIONAL_BREAKPOINT_ANNOTATION_TYPE
: EditorContext.BREAKPOINT_ANNOTATION_TYPE)
: (isConditional
? EditorContext.DISABLED_CONDITIONAL_BREAKPOINT_ANNOTATION_TYPE
: EditorContext.DISABLED_BREAKPOINT_ANNOTATION_TYPE);
// } else if (b instanceof FieldBreakpoint) {
// annotationType = b.isEnabled () ?
// EditorContext.FIELD_BREAKPOINT_ANNOTATION_TYPE :
// EditorContext.DISABLED_FIELD_BREAKPOINT_ANNOTATION_TYPE;
// } else if (b instanceof MethodBreakpoint) {
// annotationType = b.isEnabled () ?
// EditorContext.METHOD_BREAKPOINT_ANNOTATION_TYPE :
// EditorContext.DISABLED_METHOD_BREAKPOINT_ANNOTATION_TYPE;
} else {
throw new IllegalStateException(b.toString());
}
if (isInvalid && b.isEnabled()) annotationType += "_broken";
return annotationType;
}
public void annotate(final FileObject fo) {
synchronized (breakpointToAnnotations) {
if (annotatedFiles.contains(fo)) {
// Already annotated
return;
}
Set<VisageLineBreakpoint> annotatedBreakpoints = breakpointToAnnotations.keySet();
for (Breakpoint breakpoint : DebuggerManager.getDebuggerManager().getBreakpoints()) {
if (isAnnotatable(breakpoint)) {
VisageLineBreakpoint b = (VisageLineBreakpoint) breakpoint;
if (!annotatedBreakpoints.contains(b)) {
b.addPropertyChangeListener(this);
breakpointToAnnotations.put(b, new WeakSet<Annotation>());
LineTranslations.getTranslations().registerForLineUpdates(b);
}
addAnnotationTo(b, fo);
}
}
annotatedFiles.add(fo);
}
if (attachManagerListener) {
attachManagerListener = false;
DebuggerManager.getDebuggerManager()
.addDebuggerListener(
WeakListeners.create(
DebuggerManagerListener.class, this, DebuggerManager.getDebuggerManager()));
}
}
public void breakpointAdded(Breakpoint breakpoint) {
if (isAnnotatable(breakpoint)) {
VisageLineBreakpoint b = (VisageLineBreakpoint) breakpoint;
// JPDABreakpoint b = (JPDABreakpoint) breakpoint;
b.addPropertyChangeListener(this);
RequestProcessor.getDefault().post(new AnnotationRefresh(b, false, true));
// if( b instanceof LineBreakpoint ) {
VisageLineBreakpoint lb = (VisageLineBreakpoint) breakpoint;
LineTranslations.getTranslations().registerForLineUpdates(lb);
// }
}
}
// Is called under synchronized (breakpointToAnnotations)
private void addAnnotationTo(VisageLineBreakpoint b, FileObject fo) {
int[] lines = getAnnotationLines(b, fo);
if (lines == null || lines.length == 0) {
return;
}
String condition;
if (b instanceof VisageLineBreakpoint) {
condition = ((VisageLineBreakpoint) b).getCondition();
// } else if (b instanceof FieldBreakpoint) {
// condition = ((FieldBreakpoint) b).getCondition();
// } else if (b instanceof MethodBreakpoint) {
// condition = ((MethodBreakpoint) b).getCondition();
} else {
throw new IllegalStateException(b.toString());
}
boolean isConditional = (condition != null) && condition.trim().length() > 0;
String annotationType = getAnnotationType(b, isConditional);
DataObject dataObject;
try {
dataObject = DataObject.find(fo);
} catch (DataObjectNotFoundException donfex) {
donfex.printStackTrace();
return;
}
LineCookie lc = dataObject.getCookie(LineCookie.class);
if (lc == null) return;
List<DebuggerBreakpointAnnotation> annotations = new ArrayList<DebuggerBreakpointAnnotation>();
for (int l : lines) {
try {
Line line = lc.getLineSet().getCurrent(l - 1);
DebuggerBreakpointAnnotation annotation =
new DebuggerBreakpointAnnotation(annotationType, line, b.getLineBreakpoint());
annotations.add(annotation);
} catch (IndexOutOfBoundsException e) {
} catch (IllegalArgumentException e) {
}
}
if (annotations.size() == 0) {
return;
}
Set<Annotation> bpAnnotations = breakpointToAnnotations.get(b);
if (bpAnnotations == null) {
breakpointToAnnotations.put(b, new WeakSet<Annotation>(annotations));
} else {
bpAnnotations.addAll(annotations);
breakpointToAnnotations.put(b, bpAnnotations);
}
}
/** @return The annotation lines or <code>null</code>. */
private static int[] getAnnotationLines(VisageLineBreakpoint b, FileObject fo) {
if (b instanceof VisageLineBreakpoint) {
VisageLineBreakpoint lb = (VisageLineBreakpoint) b;
try {
if (fo.getURL().equals(new URL(lb.getURL()))) {
return new int[] {lb.getLineNumber()};
}
} catch (MalformedURLException ex) {
Exceptions.printStackTrace(ex);
} catch (FileStateInvalidException ex) {
Exceptions.printStackTrace(ex);
}
return null;
// } else if (b instanceof FieldBreakpoint) {
// FieldBreakpoint fb = (FieldBreakpoint) b;
// String className = fb.getClassName();
// String fieldName = fb.getFieldName();
// int line = EditorContextImpl.getFieldLineNumber(fo, className, fieldName);
// return new int[] { line };
// } else if (b instanceof MethodBreakpoint) {
// MethodBreakpoint mb = (MethodBreakpoint) b;
// String[] filters = mb.getClassFilters();
// int[] lns = new int[] {};
// for (int i = 0; i < filters.length; i++) {
// // TODO: annotate also other matched classes
// if (!filters[i].startsWith("*") && !filters[i].endsWith("*")) {
// int[] newlns = EditorContextImpl.getMethodLineNumbers(
// fo, filters[i], mb.getClassExclusionFilters(),
// mb.getMethodName(),
// mb.getMethodSignature());
// if (lns.length == 0) {
// lns = newlns;
// } else {
// int[] ln = new int[lns.length + newlns.length];
// System.arraycopy(lns, 0, ln, 0, lns.length);
// System.arraycopy(newlns, 0, ln, lns.length, newlns.length);
// lns = ln;
// }
// }
// }
// return lns;
} else {
throw new IllegalStateException(b.toString());
}
}