@Override
public void connectorXReferenceRemoved(Connector connector, final IXReference xref) {
// Thread thread = new Thread(new Runnable() {
//
// @Override
// public void run() {
IResource resource = xref.getSource().getResource();
try {
String strId = ArchitectureModel.xrefStringFactory.toString(xref);
Long id = violations.get(strId);
if (id == null) return;
IMarker marker = resource.findMarker(id.longValue());
if (marker != null) marker.delete();
violations.remove(strId);
} catch (CoreException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// }
// });thread.start();
}
public static int getErrorTicksFromMarkers(
final IResource res, final int depth, final ISourceReference sourceElement)
throws CoreException {
if (res == null || !res.isAccessible()) {
return 0;
}
int severity = 0;
if (sourceElement == null) {
severity = res.findMaxProblemSeverity(IMarker.PROBLEM, true, depth);
} else {
final IMarker[] markers = res.findMarkers(IMarker.PROBLEM, true, depth);
if (markers != null && markers.length > 0) {
for (int i = 0; i < markers.length && severity != IMarker.SEVERITY_ERROR; i++) {
final IMarker curr = markers[i];
if (isMarkerInRange(curr, sourceElement)) {
final int val = curr.getAttribute(IMarker.SEVERITY, -1);
if (val == IMarker.SEVERITY_WARNING || val == IMarker.SEVERITY_ERROR) {
severity = val;
}
}
}
}
}
if (severity == IMarker.SEVERITY_ERROR) {
return ERRORTICK_ERROR;
} else if (severity == IMarker.SEVERITY_WARNING) {
return ERRORTICK_WARNING;
}
return 0;
}
private final void handleOutputLine(String line) {
Matcher m = warningErrorPattern.matcher(line);
if (m.find()) {
String filename = m.group(1);
int lineNumber = Integer.parseInt(m.group(2));
// int colNumber = Integer.parseInt(m.group(3));
String msg = m.group(4);
// Determine the severity
int severity = IMarker.SEVERITY_INFO;
if (msg.toLowerCase().contains("error")) severity = IMarker.SEVERITY_ERROR;
else if (msg.toLowerCase().contains("warning")) severity = IMarker.SEVERITY_WARNING;
// Find the resource and create a marker
for (Resource r : sourceResources) {
IResource res = getIResource(r);
if (filename.equals(res.getName())) {
IMarker marker;
try {
marker = res.createMarker(IMarker.PROBLEM);
marker.setAttribute(IMarker.MESSAGE, msg);
marker.setAttribute(IMarker.SEVERITY, severity);
marker.setAttribute(IMarker.LINE_NUMBER, lineNumber);
marker.setAttribute(PreferenceConstants.OCARINA_MARKER, "true");
} catch (CoreException e) {
throw new RuntimeException(e);
}
}
}
}
out().println(line);
}
private static String insertTagsForErrors(String fileText, IMarker[] markers)
throws CoreException {
StringBuilder result = new StringBuilder(fileText);
Integer offset = 0;
for (IMarker marker : markers) {
int openTagStartOffset = getOpenTagStartOffset(marker);
int closeTagStartOffset = getCloseTagStartOffset(marker);
switch (marker.getAttribute(IMarker.SEVERITY, 0)) {
case IMarker.SEVERITY_ERROR:
offset += insertTagByOffset(result, ERROR_TAG_OPEN, openTagStartOffset, offset);
offset += insertTagByOffset(result, ERROR_TAG_CLOSE, closeTagStartOffset, offset);
break;
case IMarker.SEVERITY_WARNING:
offset += insertTagByOffset(result, WARNING_TAG_OPEN, openTagStartOffset, offset);
offset += insertTagByOffset(result, WARNING_TAG_CLOSE, closeTagStartOffset, offset);
break;
default:
break;
}
}
return result.toString();
}
/**
* Resolves the {@link IBreakpoint} from the given editor and ruler information. Returns <code>
* null</code> if no breakpoint exists or the operation fails.
*
* @param editor the editor
* @param info the current ruler information
* @return the {@link IBreakpoint} from the current editor position or <code>null</code>
*/
protected IBreakpoint getBreakpointFromEditor(ITextEditor editor, IVerticalRulerInfo info) {
IAnnotationModel annotationModel =
editor.getDocumentProvider().getAnnotationModel(editor.getEditorInput());
IDocument document = editor.getDocumentProvider().getDocument(editor.getEditorInput());
if (annotationModel != null) {
@SuppressWarnings("unchecked")
Iterator<Annotation> iterator = annotationModel.getAnnotationIterator();
while (iterator.hasNext()) {
Object object = iterator.next();
if (object instanceof SimpleMarkerAnnotation) {
SimpleMarkerAnnotation markerAnnotation = (SimpleMarkerAnnotation) object;
IMarker marker = markerAnnotation.getMarker();
try {
if (marker.isSubtypeOf(IBreakpoint.BREAKPOINT_MARKER)) {
Position position = annotationModel.getPosition(markerAnnotation);
int line = document.getLineOfOffset(position.getOffset());
if (line == info.getLineOfLastMouseButtonActivity()) {
IBreakpoint breakpoint =
DebugPlugin.getDefault().getBreakpointManager().getBreakpoint(marker);
if (breakpoint != null) {
return breakpoint;
}
}
}
} catch (CoreException e) {
} catch (BadLocationException e) {
}
}
}
}
return null;
}
/** @since 2.3 */
@Override
public List<?> getTargetObjects(Object object, IMarker marker) {
if (object instanceof AdapterFactoryEditingDomain) {
ArrayList<Object> result = new ArrayList<Object>();
AdapterFactoryEditingDomain editingDomain = (AdapterFactoryEditingDomain) object;
String uriAttribute = marker.getAttribute(EValidator.URI_ATTRIBUTE, null);
if (uriAttribute != null) {
URI uri = URI.createURI(uriAttribute);
EObject eObject = editingDomain.getResourceSet().getEObject(uri, true);
if (eObject != null) {
result.add(editingDomain.getWrapper(eObject));
}
}
String relatedURIsAttribute = marker.getAttribute(EValidator.RELATED_URIS_ATTRIBUTE, null);
if (relatedURIsAttribute != null) {
for (String relatedURI : relatedURIsAttribute.split(" ")) {
URI uri = URI.createURI(URI.decode(relatedURI));
EObject eObject = editingDomain.getResourceSet().getEObject(uri, true);
if (eObject != null) {
result.add(editingDomain.getWrapper(eObject));
}
}
}
return result;
} else {
return super.getTargetObjects(object, marker);
}
}
public void markFile() {
if (!markerHandle.exists()) {
return;
}
try {
IMarker[] markers =
markerHandle.findMarkers(modelMarker.getMarkerId(), true, IResource.DEPTH_ZERO);
if (modelMarker.isActive(markers)) {
if (markers.length == 0) {
IMarker marker = markerHandle.createMarker(modelMarker.getMarkerId());
IResource resource = (IResource) markerHandle.getAdapter(IResource.class);
marker.setAttributes(
new String[] {
MarkerProblem.ATTRIB_DESCRIPTION,
MarkerProblem.ATTRIB_PATH,
MarkerProblem.ATTRIB_SOURCE_OPENER
},
getMarkerAttributes(resource));
}
} else {
markerHandle.deleteMarkers(modelMarker.getMarkerId(), true, IResource.DEPTH_ZERO);
}
} catch (CoreException e) {
new Logger(CharacterCorePlugin.ID).error(Messages.ResourceModelMarker_ErrorWhileMarking, e);
}
}
@Override
public ICompletionProposal getCompletionProposal(final IMarker marker, final IDocument document) {
String msg = marker.getAttribute(IMarker.MESSAGE, ""); // $NON-NLS-1$
String toSearch = GhcMessages.WARNING_INFERREDTYPE_START;
int ix = msg.toLowerCase().indexOf(toSearch);
String type = msg.substring(ix + toSearch.length()).trim();
int line = marker.getAttribute(IMarker.LINE_NUMBER, 0);
try {
int offset = document.getLineOffset(line - 1);
String txt = type + PlatformUtil.NL;
return new CompletionProposal(
getLineStartAddition(txt, marker.getResource()),
offset,
0,
offset + txt.length(),
HaskellUIImages.getImage(IImageNames.TYPE_SIGNATURE),
getLabel(),
null,
null);
// doc.replace( offset, 0, type+NL );
} catch (BadLocationException ex) {
HaskellUIPlugin.log(ex);
}
return null;
}
/**
* This method is here for use by the SABER validator's reporter instance ONLY. Do not use. See
* defect 260144 for details.
*/
@SuppressWarnings("unchecked")
public static IMarker setPriority(IMarker item, int priority) throws CoreException {
Map attrib = item.getAttributes();
attrib.put(IMarker.PRIORITY, new Integer(priority));
item.setAttributes(attrib);
return item;
}
private void updateStatusLine(IStructuredSelection selection) {
String message;
if (selection == null || selection.size() == 0) {
message = "";
} else if (selection.size() == 1) {
Object sel = selection.getFirstElement();
if (sel instanceof IMarker) {
IMarker marker = (IMarker) sel;
message = marker.getAttribute(IMarker.MESSAGE, "");
} else {
message = "";
}
} else {
List<IMarker> selMarkers = new ArrayList<IMarker>();
for (Object obj : selection.toList()) {
if (obj instanceof IMarker) {
selMarkers.add((IMarker) obj);
}
}
message = getStatusSummary(selMarkers.toArray(new IMarker[selMarkers.size()]));
}
getViewSite().getActionBars().getStatusLineManager().setMessage(message);
}
/**
* Processes a new/old/updated marker.
*
* @param marker The marker being added/removed/changed
* @param nodeList the list of activity/service/provider/receiver nodes.
* @param kind the change kind. Can be {@link IResourceDelta#ADDED}, {@link
* IResourceDelta#REMOVED}, or {@link IResourceDelta#CHANGED}
*/
private void processMarker(IMarker marker, List<UiElementNode> nodeList, int kind) {
// get the data from the marker
String nodeType = marker.getAttribute(AdtConstants.MARKER_ATTR_TYPE, EMPTY);
if (nodeType == EMPTY) {
return;
}
String className = marker.getAttribute(AdtConstants.MARKER_ATTR_CLASS, EMPTY);
if (className == EMPTY) {
return;
}
for (UiElementNode ui_node : nodeList) {
if (ui_node.getDescriptor().getXmlName().equals(nodeType)) {
for (UiAttributeNode attr : ui_node.getAllUiAttributes()) {
if (attr.getDescriptor()
.getXmlLocalName()
.equals(AndroidManifestDescriptors.ANDROID_NAME_ATTR)) {
if (attr.getCurrentValue().equals(className)) {
if (kind == IResourceDelta.REMOVED) {
attr.setHasError(false);
} else {
attr.setHasError(true);
}
return;
}
}
}
}
}
}
public void setMarker(IMarker marker) throws CoreException {
super.setMarker(marker);
fCondition = (String) marker.getAttribute(IPHPDebugConstants.Condition);
Boolean enabled = (Boolean) marker.getAttribute(IPHPDebugConstants.ConditionEnabled);
fConditionEnabled = enabled != null ? enabled.booleanValue() : false;
addConditionToBP();
}
private int hasBreakpointChanges(IMarkerDelta delta, IScriptBreakpoint breakpoint) {
final String[] attrs = breakpoint.getUpdatableAttributes();
try {
final IMarker marker = delta.getMarker();
for (int i = 0; i < attrs.length; ++i) {
final String attr = attrs[i];
final Object oldValue = delta.getAttribute(attr);
final Object newValue = marker.getAttribute(attr);
if (oldValue == null) {
if (newValue != null) {
return classifyBreakpointChange(delta, breakpoint, attr);
}
continue;
}
if (newValue == null) {
return classifyBreakpointChange(delta, breakpoint, attr);
}
if (!oldValue.equals(newValue)) {
return classifyBreakpointChange(delta, breakpoint, attr);
}
}
} catch (CoreException e) {
DLTKDebugPlugin.log(e);
}
return NO_CHANGES;
}
private static int hasSpawnpointChanges(IMarkerDelta delta, IScriptBreakpoint breakpoint) {
final String[] attrs = breakpoint.getUpdatableAttributes();
try {
final IMarker marker = delta.getMarker();
for (int i = 0; i < attrs.length; ++i) {
final String attr = attrs[i];
if (IBreakpoint.ENABLED.equals(attr) || IMarker.LINE_NUMBER.equals(attr)) {
final Object oldValue = delta.getAttribute(attr);
final Object newValue = marker.getAttribute(attr);
if (oldValue == null) {
if (newValue != null) {
return IMarker.LINE_NUMBER.equals(attr) ? MAJOR_CHANGE : MINOR_CHANGE;
}
continue;
}
if (newValue == null) {
return IMarker.LINE_NUMBER.equals(attr) ? MAJOR_CHANGE : MINOR_CHANGE;
}
if (!oldValue.equals(newValue)) {
return IMarker.LINE_NUMBER.equals(attr) ? MAJOR_CHANGE : MINOR_CHANGE;
}
}
}
} catch (CoreException e) {
DLTKDebugPlugin.log(e);
}
return NO_CHANGES;
}
/** @since 2.7 */
protected void addMarkerAndLogError(URI uri, Throwable e) {
for (Pair<IStorage, IProject> storage : getStorage2UriMapper().getStorages(uri)) {
IResource resource = null;
if (storage.getFirst() instanceof IResource) {
resource = (IResource) storage.getFirst();
} else {
resource = storage.getSecond();
}
if (resource != null) {
try {
IMarker marker = resource.createMarker(MarkerTypes.NORMAL_VALIDATION);
marker.setAttribute(IMarker.MESSAGE, e.getMessage() + " - See error log for details");
marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
marker.setAttribute(IMarker.LINE_NUMBER, 1);
} catch (CoreException ce) {
logger.error("Could not create marker", ce);
}
}
}
Throwable cause = e;
if (cause instanceof CoreException) {
cause = cause.getCause();
}
if (uri == null) {
logger.error("Error during compilation.", e);
} else {
logger.error("Error during compilation of '" + uri + "'.", e);
}
}
/** @see org.eclipse.debug.ui.ISourcePresentation#getEditorInput(java.lang.Object) */
public IEditorInput getEditorInput(Object element) {
IStorageEditorInput i;
AtlStackFrame frame;
// String projectName;
String fileName;
if (element instanceof AtlStackFrame) {
frame = (AtlStackFrame) element;
if (((AtlDebugTarget) frame.getDebugTarget()).isDisassemblyMode())
return getDisassemblyEditorInput(frame);
ILaunchConfiguration configuration =
frame.getDebugTarget().getLaunch().getLaunchConfiguration();
try {
// TODO Recuperer le nom du fichier sur la stackframe
fileName =
configuration.getAttribute(
AtlLauncherTools.ATLFILENAME, AtlLauncherTools.NULLPARAMETER);
IWorkspace wks = ResourcesPlugin.getWorkspace();
IWorkspaceRoot wksroot = wks.getRoot();
i = new FileEditorInput(wksroot.getFile(new Path(fileName)));
return i;
} catch (CoreException e) {
e.printStackTrace();
}
} else if (element instanceof AtlBreakpoint) {
IMarker marker = ((AtlBreakpoint) element).getMarker();
IFile ifile = (IFile) marker.getResource();
return new FileEditorInput(ifile);
}
return null;
}
/**
* Returns the maximum problem marker severity for the given resource, and, if depth is
* IResource.DEPTH_INFINITE, its children. The return value will be one of IMarker.SEVERITY_ERROR,
* IMarker.SEVERITY_WARNING, IMarker.SEVERITY_INFO or 0, indicating that no problem markers exist
* on the given resource.
*
* @param depth TODO
*/
public static int getMaxProblemMarkerSeverity(IResource res, int depth) {
if (res == null || !res.isAccessible()) return 0;
boolean hasWarnings = false; // if resource has errors, will return error image immediately
IMarker[] markers = null;
try {
markers = res.findMarkers(IMarker.PROBLEM, true, depth);
} catch (CoreException e) {
e.printStackTrace();
}
if (markers == null) return 0; // don't know - say no errors/warnings/infos
for (int i = 0; i < markers.length; i++) {
IMarker m = markers[i];
int priority = m.getAttribute(IMarker.SEVERITY, -1);
if (priority == IMarker.SEVERITY_WARNING) {
hasWarnings = true;
} else if (priority == IMarker.SEVERITY_ERROR) {
return IMarker.SEVERITY_ERROR;
}
}
return hasWarnings ? IMarker.SEVERITY_WARNING : 0;
}
/** This leaves a bit of a mess e.g. "import " or "from " for some later process to clean up. */
private void deleteImport(PySelection ps, MarkerAnnotationAndPosition markerInfo)
throws BadLocationException, CoreException {
IMarker marker = markerInfo.markerAnnotation.getMarker();
Integer start = (Integer) marker.getAttribute(IMarker.CHAR_START);
Integer end = (Integer) marker.getAttribute(IMarker.CHAR_END);
IDocument doc = ps.getDoc();
while (start > 0) {
char c;
try {
c = doc.getChar(start - 1);
} catch (Exception e) {
break;
}
if (c == '\r' || c == '\n') {
break;
}
if (Character.isWhitespace(c) || c == ',') {
start--;
continue;
}
break;
}
ps.setSelection(start, end);
ps.deleteSelection();
}
private void openSelectedMarker() {
ISelection sel = tableViewer.getSelection();
if (sel instanceof IStructuredSelection) {
Object element = ((IStructuredSelection) sel).getFirstElement();
if (element instanceof IMarker) {
IMarker marker = (IMarker) element;
if (marker.getResource() instanceof IFile) {
try {
IDE.openEditor(getViewSite().getPage(), marker);
} catch (PartInitException e) {
ErrorDialog.openError(
getSite().getShell(),
"Error Opening Marker",
"Unable to open an editor for the given marker: " + e.getClass().getSimpleName(),
new Status(IStatus.ERROR, DartToolsPlugin.PLUGIN_ID, e.toString(), e));
DartToolsPlugin.log(e);
}
}
}
}
}
private static IMarker[] getValidationTasks(
IResource resource, String[] messageOwners, int depth) {
IMarker[] markers = getValidationTasks(resource, IMessage.ALL_MESSAGES, depth);
if (markers.length == 0) return NO_MARKERS;
IMarker[] temp = new IMarker[markers.length];
int validCount = 0;
for (IMarker marker : markers) {
Object owner = null;
try {
owner = marker.getAttribute(VALIDATION_MARKER_OWNER);
} catch (CoreException e) {
// eat it -- if it no longer exists there is nothing we can do about it
}
if ((owner == null) || !(owner instanceof String)) {
// The ValidationMigrator will remove any "unowned" validation markers.
continue;
}
for (String messageOwner : messageOwners) {
if (((String) owner).equals(messageOwner)) {
temp[validCount++] = marker;
break;
}
}
}
if (validCount == 0) return NO_MARKERS;
IMarker[] result = new IMarker[validCount];
System.arraycopy(temp, 0, result, 0, validCount);
return result;
}
private IMarker addMarker(
IResource resource,
String type,
String message,
int lineNumber,
int severity,
boolean isTransient) {
IMarker marker = null;
try {
if (resource.isAccessible()) {
if (lineNumber == -1) {
lineNumber = 1;
}
// mkleint: this strongly smells like some sort of workaround for a problem with bad marker
// cleanup.
// adding is adding and as such shall always be performed.
marker = findMarker(resource, type, message, lineNumber, severity, isTransient);
if (marker != null) {
// This marker already exists
return marker;
}
marker = resource.createMarker(type);
marker.setAttribute(IMarker.MESSAGE, message);
marker.setAttribute(IMarker.SEVERITY, severity);
marker.setAttribute(IMarker.TRANSIENT, isTransient);
marker.setAttribute(IMarker.LINE_NUMBER, lineNumber);
log.debug("Created marker '{}' on resource '{}'.", message, resource.getFullPath());
}
} catch (CoreException ex) {
log.error("Unable to add marker; " + ex.toString(), ex); // $NON-NLS-1$
}
return marker;
}
public boolean isDefinedInParent() {
IMarker mark = ann.getMarker();
String isElsewhere = mark.getAttribute(IMavenConstants.MARKER_CAUSE_RESOURCE_PATH, null);
if (isElsewhere != null) {
return true;
}
return false;
}
@Override
public String getText(Object element) {
if (element instanceof IMarker) {
IMarker marker = (IMarker) element;
return marker.getAttribute(IMarker.MESSAGE, null);
} else {
return super.getText(element);
}
}
static void applyCatchByReferenceQuickFix(IMarker marker, IDocument document, boolean addConst) {
try {
int left = marker.getAttribute(IMarker.CHAR_START, -1);
int right = marker.getAttribute(IMarker.CHAR_END, -1);
String inStr = document.get(left, right - left);
document.replace(left, right - left, getCatchByReferenceString(inStr, addConst));
} catch (BadLocationException e) {
CheckersUiActivator.log(e);
}
}
@Test
public void testNewArrayDeleteQuickFix() throws CoreException {
IMarker newArrayDeleteMarker = markers[9];
int markerLine = newArrayDeleteMarker.getAttribute(IMarker.LINE_NUMBER, -1);
createResolutionAndApply(newArrayDeleteMarker);
String newContent = getLineContent(document, markerLine);
assertTrue(newContent.contains("delete[]")); // $NON-NLS-1$
}
/**
* Create a marker on the given resource
*
* @param resource the resource
* @param severity the severity constant
* @param message the message
* @param lineNumber the line number
*/
public void createMarker(IResource resource, int severity, String message, Integer lineNumber) {
try {
IMarker marker = resource.createMarker(MARKER_TYPE);
marker.setAttribute(IMarker.MESSAGE, message);
marker.setAttribute(IMarker.SEVERITY, severity);
marker.setAttribute(IMarker.LINE_NUMBER, lineNumber);
} catch (CoreException e) {
logException(e.getMessage(), e);
}
}
@Override
public void setMarker(IMarker marker) throws CoreException {
super.setMarker(marker);
m_methodName = marker.getAttribute(METHOD_NAME, null);
m_methodSignature = marker.getAttribute(METHOD_SIGNATURE, null);
String typePattern = marker.getAttribute(TYPE_NAME, ""); // $NON-NLS-1$
if (typePattern != null) {
fPattern = Pattern.compile(convertToRegularExpression(typePattern));
}
}
private boolean isNeedToCreate(IMarker marker) {
String message = marker.getAttribute(IMarker.MESSAGE, "");
String attribute = marker.getAttribute(ATTRIBUTE_NAME, "");
if (attribute.equals(VALIDATOR_ID)
&& marker.getResource() instanceof IFile
&& message.endsWith(MESSAGE)) {
return true;
}
return false;
}
/**
* This method changes all validator markers on the IResource and its children. All markers owned
* by "from" have their owner reassigned to "to".
*/
public static void updateOwner(String from, String to, IResource resource) throws CoreException {
IMarker[] ownedMarkers = getValidationTasks(resource, from);
if (ownedMarkers == null) {
return;
}
for (int i = 0; i < ownedMarkers.length; i++) {
IMarker marker = ownedMarkers[i];
marker.setAttribute(VALIDATION_MARKER_OWNER, to);
}
}
public static boolean canHandle(final IMarker marker) {
final int code = marker.getAttribute(IMarker.PROBLEM, 0);
final String sourceId = marker.getAttribute(IMarker.SOURCE_ID, "");
if (marker.getResource().getName().endsWith(SpdPackage.FILE_EXTENSION)
&& code == EventPortConstraint.STATUS_CODE
&& sourceId.equals(EventPortConstraint.SOURCE_ID)) {
return true;
}
return false;
}